[CSApply] Compare variable's type with the base type of the enum we're assigning to

Author: theblixguy

lib/Sema/CSApply.cpp

@@ -2476,13 +2476,17 @@ namespace {
                                          memberName,
                                          defaultMemberLookupOptions);
 
-          // Filter out any functions or instance members
+          // Filter out any functions, instance members or enum cases with
+          // associated values.
           results.filter([](const LookupResultEntry entry, bool isOuter) {
             if (auto member = entry.getValueDecl()) {
               if (isa<FuncDecl>(member))
                 return false;
               if (member->isInstanceMember())
                 return false;
+              if (auto EED = dyn_cast<EnumElementDecl>(member)) {
+                return !EED->hasAssociatedValues();
+              }
             }
 
             return true;
@@ -2493,20 +2497,13 @@ namespace {
           }
 
           if (auto member = results.front().getValueDecl()) {
-            // If we have something like 'static let none = 1', then ignore.
+            // If this is a variable whose type does not match the base type
+            // of the target then ignore it.
             if (auto VD = dyn_cast<VarDecl>(member)) {
-              if (!VD->getInterfaceType()->isEqual(
-                      baseTyNominalDecl->getDeclaredInterfaceType()))
+              auto baseType = DSCE->getType()->lookThroughAllOptionalTypes();
+              if (!VD->getInterfaceType()->isEqual(baseType))
                 return;
             }
-
-            // Return if the member is an enum case w/ assoc values, as we only
-            // care (for now) about cases with no assoc values (like none)
-            if (auto EED = dyn_cast<EnumElementDecl>(member)) {
-              if (EED->hasAssociatedValues()) {
-                return;
-              }
-            }
 
             // Emit a diagnostic with some fixits
             auto baseTyName = baseTy->getCanonicalType().getString();

test/decl/enum/enumtest.swift

@@ -497,3 +497,29 @@ let _: EnumWithStaticNone4? = .none // expected-warning {{assuming you mean 'Opt
 
 let _: EnumWithStaticFuncNone1? = .none // Okay
 let _: EnumWithStaticFuncNone2? = .none // Okay
+
+/// Make sure we diagnose generic ones as well including conditional ones ///
+
+enum GenericEnumWithStaticNone<T> {
+  case a
+  static var none: GenericEnumWithStaticNone<Int> { .a }
+}
+
+let _: GenericEnumWithStaticNone<Int>? = .none // expected-warning {{assuming you mean 'Optional<GenericEnumWithStaticNone<Int>>.none'; did you mean 'GenericEnumWithStaticNone<Int>.none' instead?}}
+// expected-note@-1 {{explicitly specify 'Optional' to silence this warning}}{{42-42=Optional}}
+// expected-note@-2 {{use 'GenericEnumWithStaticNone<Int>.none' instead}}{{42-42=GenericEnumWithStaticNone<Int>}}
+let _: GenericEnumWithStaticNone<String>? = .none // Okay
+let _: GenericEnumWithStaticNone? = .none // Okay
+
+enum GenericEnumWithoutNone<T> {
+  case a
+}
+
+extension GenericEnumWithoutNone where T == Int {
+  static var none: GenericEnumWithoutNone<Int> { .a }
+}
+
+let _: GenericEnumWithoutNone<Int>? = .none // expected-warning {{assuming you mean 'Optional<GenericEnumWithoutNone<Int>>.none'; did you mean 'GenericEnumWithoutNone<Int>.none' instead?}}
+// expected-note@-1 {{explicitly specify 'Optional' to silence this warning}}{{39-39=Optional}}
+// expected-note@-2 {{use 'GenericEnumWithoutNone<Int>.none' instead}}{{39-39=GenericEnumWithoutNone<Int>}}
+let _: GenericEnumWithoutNone<String>? = .none // Okay