[Sema] Add warning for ambiguous value assignment when using Optional

include/swift/AST/DiagnosticsSema.def

@@ -1391,6 +1391,8 @@ ERROR(pattern_binds_no_variables,none,
       "variables",
       (unsigned))
 
+WARNING(ambiguous_pattern_binding_enum,none, "the enum case is ambiguous", ())
+
 ERROR(nscoding_unstable_mangled_name,none,
       "%select{private|fileprivate|nested|local}0 class %1 has an "
       "unstable name when archiving via 'NSCoding'",

lib/Sema/TypeCheckDecl.cpp

@@ -2372,6 +2372,35 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
       if (!PBD->isInitializerChecked(i) && PBD->getInit(i))
         TC.typeCheckPatternBinding(PBD, i);
     }
+
+    // If the pattern is optional and we're referring to an enum case via the dot syntax (i.e .none)
+    // and the enum case matches the Optional<T>.none case then emit a diagnostic
+    for (unsigned i = 0, e = PBD->getNumPatternEntries(); i != e; ++i) {
+      if (auto baseType = PBD->getPattern(i)->getType()->getOptionalObjectType()) {
+        if (auto DSCE = dyn_cast<DotSyntaxCallExpr>(PBD->getInit(i))) {
+          if (auto EED = dyn_cast<EnumElementDecl>(DSCE->getCalledValue())) {
+            if (EED->getParentEnum()->isOptionalDecl()) {
+
+              // Lookup the case in the original enum decl
+              auto results = TC.lookupMember(PBD->getModuleContext(), baseType, EED->getName(), defaultMemberLookupOptions);
+              bool caseExistsInBase = false;
+
+              for (LookupResultEntry result : results) {
+                if (auto *eed = dyn_cast<EnumElementDecl>(result.getValueDecl())) {
+                  caseExistsInBase = true;
+                  break;
+                }
+              }
+
+              // Emit a warning dignostic
+              if (caseExistsInBase) {
+                TC.Diags.diagnose(DSCE->getLoc(), swift::diag::ambiguous_pattern_binding_enum);
+              }
+            }
+          }
+        }
+      }
+    }
   }
 
   void visitSubscriptDecl(SubscriptDecl *SD) {

test/decl/enum/enumtest.swift

@@ -326,3 +326,20 @@ enum Lens<T> {
   case baz((inout T) -> ()) // ok
   case quux((inout T, inout T) -> ()) // ok
 }
+
+enum Foo {
+  case bar
+  case none
+}
+
+let _: Foo? = .none // expected-warning {{the enum case is ambiguous}}
+let _: Foo?? = .none // expected-warning {{the enum case is ambiguous}}
+
+let _: Foo = .none // ok
+let _: Foo = .bar // ok
+let _: Foo? = .bar // ok
+let _: Foo?? = .bar // ok
+let _: Foo = Foo.bar // ok
+let _: Foo = Foo.none // ok
+let _: Foo? = Foo.none // ok
+let _: Foo?? = Foo.none // ok