[ClangImporter] Prefer later enum_extensibility over earlier ones

Since NS_ENUM has an enum_extensibility(open) in it already, we want
to allow people to undo that by sticking enum_extensibility(closed) on
the end of their enum.

Author: jrose-apple

lib/ClangImporter/ImportEnumInfo.cpp

@@ -33,6 +33,55 @@ STATISTIC(EnumInfoNumCacheMisses, "# of times the enum info cache was missed");
 using namespace swift;
 using namespace importer;
 
+static void rememberToChangeThisBehaviorInSwift5() {
+  // Note: Once the compiler starts advertising itself as Swift 5, even
+  // Swift 4 mode is supposed to treat C enums as non-exhaustive. Because
+  // it's Swift 4 mode, failing to switch over the whole enum will only
+  // produce a warning, not an error.
+  //
+  // This is an assertion rather than a condition because we /want/ to be
+  // reminded to take it out when we're ready for the Swift 5 release.
+  assert(version::getSwiftNumericVersion().first < 5 &&
+         "When the compiler starts advertising itself as Swift 5, even "
+         "Swift 4 mode is supposed to treat C enums as non-exhaustive.");
+}
+
+/// Find the last extensibility attribute on \p decl as arranged by source
+/// location...unless there's an API note, in which case that one wins.
+///
+/// This is not what Clang will do, but it's more useful for us since CF_ENUM
+/// already has enum_extensibility(open) in it.
+static clang::EnumExtensibilityAttr *
+getBestExtensibilityAttr(clang::Preprocessor &pp, const clang::EnumDecl *decl) {
+  clang::EnumExtensibilityAttr *bestSoFar = nullptr;
+  const clang::SourceManager &sourceMgr = pp.getSourceManager();
+  for (auto *next : decl->specific_attrs<clang::EnumExtensibilityAttr>()) {
+    if (next->getLocation().isInvalid()) {
+      // This is from API notes -- use it!
+      return next;
+    }
+
+    // Temporarily ignore enum_extensibility attributes inside CF_ENUM and
+    // similar. In the Swift 5 release we can start respecting this annotation,
+    // meaning this entire block can be dropped.
+    {
+      rememberToChangeThisBehaviorInSwift5();
+      auto loc = next->getLocation();
+      if (loc.isMacroID() &&
+          pp.getImmediateMacroName(loc) == "__CF_ENUM_ATTRIBUTES") {
+        continue;
+      }
+    }
+
+    if (!bestSoFar ||
+        sourceMgr.isBeforeInTranslationUnit(bestSoFar->getLocation(),
+                                            next->getLocation())) {
+      bestSoFar = next;
+    }
+  }
+  return bestSoFar;
+}
+
 /// Classify the given Clang enumeration to describe how to import it.
 void EnumInfo::classifyEnum(const clang::EnumDecl *decl,
                             clang::Preprocessor &pp) {
@@ -58,7 +107,7 @@ void EnumInfo::classifyEnum(const clang::EnumDecl *decl,
     kind = EnumKind::Options;
     return;
   }
-  if (auto *attr = decl->getAttr<clang::EnumExtensibilityAttr>()) {
+  if (auto *attr = getBestExtensibilityAttr(pp, decl)) {
     if (attr->getExtensibility() == clang::EnumExtensibilityAttr::Closed)
       kind = EnumKind::FrozenEnum;
     else
@@ -82,7 +131,7 @@ void EnumInfo::classifyEnum(const clang::EnumDecl *decl,
 
   // Was the enum declared using *_ENUM or *_OPTIONS?
   // FIXME: Stop using these once flag_enum and enum_extensibility
-  // have been adopted everywhere, or at least relegate them to Swift 3 mode
+  // have been adopted everywhere, or at least relegate them to Swift 4 mode
   // only.
   auto loc = decl->getLocStart();
   if (loc.isMacroID()) {

test/ClangImporter/Inputs/custom-modules/EnumExhaustivity.apinotes

@@ -0,0 +1,4 @@
+Name: EnumExhaustivity
+Tags:
+- Name: RegularEnumTurnedExhaustiveThenBackViaAPINotes
+  EnumExtensibility: open

test/ClangImporter/Inputs/custom-modules/EnumExhaustivity.h

@@ -13,3 +13,31 @@ typedef MY_EXHAUSTIVE_ENUM(ExhaustiveEnum) {
   ExhaustiveEnumA,
   ExhaustiveEnumB
 };
+
+typedef MY_ENUM(RegularEnumTurnedExhaustive) {
+  RegularEnumTurnedExhaustiveA,
+  RegularEnumTurnedExhaustiveB
+} __attribute__((enum_extensibility(closed)));
+
+enum AnotherRegularEnumTurnedExhaustive {
+  AnotherRegularEnumTurnedExhaustiveA,
+  AnotherRegularEnumTurnedExhaustiveB
+} __attribute__((enum_extensibility(open))) __attribute__((enum_extensibility(closed)));
+
+typedef MY_ENUM(RegularEnumTurnedExhaustiveThenBackViaAPINotes) {
+  RegularEnumTurnedExhaustiveThenBackViaAPINotesA,
+  RegularEnumTurnedExhaustiveThenBackViaAPINotesB
+} __attribute__((enum_extensibility(closed)));
+
+typedef MY_ENUM(ForwardDeclaredTurnedExhaustive);
+enum ForwardDeclaredTurnedExhaustive {
+  ForwardDeclaredTurnedExhaustiveA,
+  ForwardDeclaredTurnedExhaustiveB
+} __attribute__((enum_extensibility(closed)));
+
+enum __attribute__((enum_extensibility(open))) ForwardDeclaredOnly;
+enum __attribute__((enum_extensibility(closed))) ForwardDeclaredOnly;
+enum ForwardDeclaredOnly {
+  ForwardDeclaredOnlyA,
+  ForwardDeclaredOnlyB
+};

test/ClangImporter/Inputs/enum-inferred-exhaustivity.h

@@ -8,3 +8,9 @@
 typedef CF_ENUM(EnumWithDefaultExhaustivity) {
   EnumWithDefaultExhaustivityLoneCase
 };
+
+// This name is also specially recognized by Swift.
+#define __CF_ENUM_ATTRIBUTES __attribute__((enum_extensibility(open)))
+typedef CF_ENUM(EnumWithSpecialAttributes) {
+  EnumWithSpecialAttributesLoneCase
+} __CF_ENUM_ATTRIBUTES;

test/ClangImporter/enum-exhaustivity.swift

@@ -1,6 +1,6 @@
 // RUN: %target-swift-frontend -typecheck %s -I %S/Inputs/custom-modules -verify -warnings-as-errors -enable-nonfrozen-enum-exhaustivity-diagnostics
 
-// RUN: %target-swift-ide-test -source-filename %s -print-module -module-to-print EnumExhaustivity -I %S/Inputs/custom-modules | %FileCheck -check-prefix=CHECK %s
+// RUN: %target-swift-ide-test -source-filename %s -print-module -module-to-print EnumExhaustivity -I %S/Inputs/custom-modules | %FileCheck %s
 
 // CHECK-LABEL: {{^}}enum RegularEnum : {{.+}} {
 // CHECK:      case A
@@ -13,6 +13,7 @@
 // CHECK-NEXT: case B
 // CHECK-NEXT: {{^}$}}
 
+
 import EnumExhaustivity
 
 func test(_ value: RegularEnum, _ exhaustiveValue: ExhaustiveEnum) {
@@ -26,3 +27,31 @@ func test(_ value: RegularEnum, _ exhaustiveValue: ExhaustiveEnum) {
   case .B: break
   }
 }
+
+func testAttributes(
+  _ rete: RegularEnumTurnedExhaustive,
+  _ arete: AnotherRegularEnumTurnedExhaustive,
+  _ retetb: RegularEnumTurnedExhaustiveThenBackViaAPINotes,
+  _ fdte: ForwardDeclaredTurnedExhaustive,
+  _ fdo: ForwardDeclaredOnly
+) {
+  switch rete {
+  case .A, .B: break
+  }
+
+  switch arete {
+  case .A, .B: break
+  }
+
+  switch retetb { // expected-error {{switch must be exhaustive}} expected-note {{do you want to add a default clause?}}
+  case .A, .B: break
+  }
+
+  switch fdte {
+  case .A, .B: break
+  }
+
+  switch fdo {
+  case .A, .B: break
+  }
+}

test/ClangImporter/enum-inferred-exhaustivity.swift

@@ -10,3 +10,10 @@ func test(_ value: EnumWithDefaultExhaustivity) {
   case .loneCase: break
   }
 }
+
+func test(_ value: EnumWithSpecialAttributes) {
+  // Same, but with the attributes macro shipped in the Xcode 9 SDKs.
+  switch value { // expected-error {{switch must be exhaustive}} expected-note {{do you want to add a default clause?}}
+  case .loneCase: break
+  }
+}