Improve imported enums' lowercased case diagnostics (26245512) (#2716)

* Diagnose enum cases renamed to lowercase

When importing foreign enum cases, we create a new case with a lowercase
name, and set the renamed unavailability bits on the imported name, so
they are still visible to the compiler but unavailable, so we can throw
a diagnostic.

Renamed enum cases can be found by digging through a VarDecl in the AST,
and there were no availability checks there. This area probably needs
deeper refactoring, but add an UnavailableInCurrentSwift check for now.

https://bugs.swift.org/browse/SR-1496
rdar://problem/26245512

* [Sema] Check for any unavailability with rename when suggesting rename

of enum cases, not just ones that aren't available in the current
version of Swift.

https://bugs.swift.org/browse/SR-1496
rdar://problem/26245512

* Reuse some unavailable diagnosis code in the type checker

This could still stand some more refactoring but reuses the renaming
diagnostic.

Author: bitjammer

lib/Sema/TypeCheckPattern.cpp

@@ -32,7 +32,10 @@ using namespace swift;
 /// This requires the getter's body to have a certain syntactic form. It should
 /// be kept in sync with importEnumCaseAlias in the ClangImporter library.
 static EnumElementDecl *
-extractEnumElement(const VarDecl *constant) {
+extractEnumElement(TypeChecker &TC, DeclContext *DC, SourceLoc UseLoc,
+                   const VarDecl *constant) {
+  TC.diagnoseExplicitUnavailability(constant, UseLoc, DC, nullptr);
+
   const FuncDecl *getter = constant->getGetter();
   if (!getter)
     return nullptr;
@@ -62,7 +65,8 @@ extractEnumElement(const VarDecl *constant) {
 /// If there are no enum elements but there are properties, attempts to map
 /// an arbitrary property to an enum element using extractEnumElement.
 static EnumElementDecl *
-filterForEnumElement(LookupResult foundElements) {
+filterForEnumElement(TypeChecker &TC, DeclContext *DC, SourceLoc UseLoc,
+                     LookupResult foundElements) {
   EnumElementDecl *foundElement = nullptr;
   VarDecl *foundConstant = nullptr;
 
@@ -86,32 +90,32 @@ filterForEnumElement(LookupResult foundElements) {
   }
 
   if (!foundElement && foundConstant && foundConstant->hasClangNode())
-    foundElement = extractEnumElement(foundConstant);
+    foundElement = extractEnumElement(TC, DC, UseLoc, foundConstant);
 
   return foundElement;
 }
 
 /// Find an unqualified enum element.
 static EnumElementDecl *
 lookupUnqualifiedEnumMemberElement(TypeChecker &TC, DeclContext *DC,
-                                   Identifier name) {
+                                   Identifier name, SourceLoc UseLoc) {
   auto lookupOptions = defaultUnqualifiedLookupOptions;
   lookupOptions |= NameLookupFlags::KnownPrivate;
   auto lookup = TC.lookupUnqualified(DC, name, SourceLoc(), lookupOptions);
-  return filterForEnumElement(lookup);
+  return filterForEnumElement(TC, DC, UseLoc, lookup);
 }
 
 /// Find an enum element in an enum type.
 static EnumElementDecl *
 lookupEnumMemberElement(TypeChecker &TC, DeclContext *DC, Type ty,
-                        Identifier name) {
+                        Identifier name, SourceLoc UseLoc) {
   assert(ty->getAnyNominal());
   // Look up the case inside the enum.
   // FIXME: We should be able to tell if this is a private lookup.
   NameLookupOptions lookupOptions
     = defaultMemberLookupOptions - NameLookupFlags::DynamicLookup;
   LookupResult foundElements = TC.lookupMember(DC, ty, name, lookupOptions);
-  return filterForEnumElement(foundElements);
+  return filterForEnumElement(TC, DC, UseLoc, foundElements);
 }
 
 namespace {
@@ -436,7 +440,8 @@ class ResolvePattern : public ASTVisitor<ResolvePattern,
 
     // FIXME: Argument labels?
     EnumElementDecl *referencedElement
-      = lookupEnumMemberElement(TC, DC, ty, ude->getName().getBaseName());
+      = lookupEnumMemberElement(TC, DC, ty, ude->getName().getBaseName(),
+                                ude->getLoc());
 
     // Build a TypeRepr from the head of the full path.
     // FIXME: Compound names.
@@ -474,7 +479,8 @@ class ResolvePattern : public ASTVisitor<ResolvePattern,
     // Try looking up an enum element in context.
     if (EnumElementDecl *referencedElement
         = lookupUnqualifiedEnumMemberElement(TC, DC,
-                                             ude->getName().getBaseName())) {
+                                             ude->getName().getBaseName(),
+                                             ude->getLoc())) {
       auto *enumDecl = referencedElement->getParentEnum();
       auto enumTy = enumDecl->getDeclaredTypeInContext();
       TypeLoc loc = TypeLoc::withoutLoc(enumTy);
@@ -558,7 +564,8 @@ class ResolvePattern : public ASTVisitor<ResolvePattern,
     if (auto compId = dyn_cast<ComponentIdentTypeRepr>(repr)) {
       // Try looking up an enum element in context.
       EnumElementDecl *referencedElement
-        = lookupUnqualifiedEnumMemberElement(TC, DC, compId->getIdentifier());
+        = lookupUnqualifiedEnumMemberElement(TC, DC, compId->getIdentifier(),
+                                             repr->getLoc());
 
       if (!referencedElement)
         return nullptr;
@@ -596,7 +603,8 @@ class ResolvePattern : public ASTVisitor<ResolvePattern,
     auto tailComponent = compoundR->Components.back();
 
     EnumElementDecl *referencedElement
-      = lookupEnumMemberElement(TC, DC, enumTy, tailComponent->getIdentifier());
+      = lookupEnumMemberElement(TC, DC, enumTy, tailComponent->getIdentifier(),
+                                tailComponent->getLoc());
     if (!referencedElement)
       return nullptr;
 
@@ -1382,8 +1390,10 @@ bool TypeChecker::coercePatternToType(Pattern *&P, DeclContext *dc, Type type,
 
     Type enumTy;
     if (!elt) {
-      if (type->getAnyNominal())
-        elt = lookupEnumMemberElement(*this, dc, type, EEP->getName());
+      if (type->getAnyNominal()) {
+        elt = lookupEnumMemberElement(*this, dc, type, EEP->getName(),
+                                      EEP->getLoc());
+      }
       if (!elt) {
         if (!type->is<ErrorType>()) {
           // Lowercasing of Swift.Optional's cases is handled in the
@@ -1513,7 +1523,8 @@ bool TypeChecker::coercePatternToType(Pattern *&P, DeclContext *dc, Type type,
     // If the element decl was not resolved (because it was spelled without a
     // type as `.Foo`), resolve it now that we have a type.
     if (!OP->getElementDecl()) {
-      auto *element = lookupEnumMemberElement(*this, dc, type, Context.Id_some);
+      auto *element = lookupEnumMemberElement(*this, dc, type, Context.Id_some,
+                                              OP->getLoc());
       if (!element) {
         diagnose(OP->getLoc(), diag::enum_element_pattern_member_not_found,
                  "Some", type);

test/ClangModules/swift2_warnings.swift

@@ -95,3 +95,10 @@ class X : NSDocument {
 }
 
 func makeCopy<T: NSWobbling>(thing: T) {} // expected-error {{'NSWobbling' has been renamed to 'Wobbling'}} {{18-28=Wobbling}} 
+
+func useLowercasedEnumCase(x: RuncingMode) {
+  switch x {
+    case .Mince: return // expected-error {{'Mince' has been renamed to 'mince'}} {{11-16=mince}}
+    case .Quince: return // expected-error {{'Quince' has been renamed to 'quince'}} {{11-17=quince}}
+  }
+}