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

Author: bitjammer

lib/Sema/TypeCheckPattern.cpp

@@ -31,7 +31,17 @@ 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, SourceLoc UseLoc, const VarDecl *constant) {
+  if (auto Attr = AvailableAttr::isUnavailable(constant)) {
+    auto Kind = Attr->getUnconditionalAvailability();
+    if (Kind == UnconditionalAvailabilityKind::UnavailableInCurrentSwift) {
+      auto diag = TC.diagnose(UseLoc, diag::availability_decl_unavailable_rename,
+                              constant->getName(), /*"replaced"*/false,
+                              /*special kind*/0, Attr->Rename);
+      diag.fixItReplace(UseLoc, Attr->Rename);
+    }
+  }
+
   const FuncDecl *getter = constant->getGetter();
   if (!getter)
     return nullptr;
@@ -61,7 +71,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, SourceLoc UseLoc,
+                     LookupResult foundElements) {
   EnumElementDecl *foundElement = nullptr;
   VarDecl *foundConstant = nullptr;
 
@@ -85,32 +96,32 @@ filterForEnumElement(LookupResult foundElements) {
   }
 
   if (!foundElement && foundConstant && foundConstant->hasClangNode())
-    foundElement = extractEnumElement(foundConstant);
+    foundElement = extractEnumElement(TC, 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, 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, UseLoc, foundElements);
 }
 
 namespace {
@@ -435,7 +446,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.
@@ -473,7 +485,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);
@@ -557,7 +570,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;
@@ -595,7 +609,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;
 
@@ -1381,8 +1396,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>())
           diagnose(EEP->getLoc(), diag::enum_element_pattern_member_not_found,
@@ -1492,7 +1509,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}}
+  }
+}