[Constraint solver] Always produce optional types for '?' patterns.

Author: DougGregor

lib/Sema/CSGen.cpp

@@ -2255,13 +2255,22 @@ namespace {
         }
         return TupleType::get(tupleTypeElts, CS.getASTContext());
       }
-      
+
+      case PatternKind::OptionalSome: {
+        // The subpattern must have optional type.
+        Type subPatternType = getTypeForPattern(
+            cast<OptionalSomePattern>(pattern)->getSubPattern(), locator);
+
+        return OptionalType::get(subPatternType);
+      }
+
       // Refutable patterns occur when checking the PatternBindingDecls in an
       // if/let or while/let condition.  They always require an initial value,
       // so they always allow unspecified types.
-#define PATTERN(Id, Parent)
-#define REFUTABLE_PATTERN(Id, Parent) case PatternKind::Id:
-#include "swift/AST/PatternNodes.def"
+      case PatternKind::Is:
+      case PatternKind::EnumElement:
+      case PatternKind::Bool:
+      case PatternKind::Expr:
         // TODO: we could try harder here, e.g. for enum elements to provide the
         // enum type.
         return CS.createTypeVariable(CS.getConstraintLocator(locator),

lib/Sema/MiscDiagnostics.cpp

@@ -3782,8 +3782,15 @@ static void diagDeprecatedObjCSelectors(const DeclContext *dc,
   const_cast<Expr *>(expr)->walk(ObjCSelectorWalker(dc, selectorTy));
 }
 
-        
-        
+/// Skip over syntactic patterns that aren't typed patterns.
+static Pattern *skipNonTypeSyntacticPatterns(Pattern *pattern) {
+  if (auto *pp = dyn_cast<ParenPattern>(pattern))
+    return skipNonTypeSyntacticPatterns(pp->getSubPattern());
+  if (auto *vp = dyn_cast<VarPattern>(pattern))
+    return skipNonTypeSyntacticPatterns(vp->getSubPattern());
+  return pattern;
+}
+
 /// Diagnose things like this, where 'i' is an Int, not an Int?
 ///     if let x: Int = i {
 static void
@@ -3815,7 +3822,19 @@ checkImplicitPromotionsInCondition(const StmtConditionElement &cond,
         .highlight(subExpr->getSourceRange());
       return;
     }
-    
+
+    // Check for 'if let' to produce a tuned diagnostic.
+    if (isa<OptionalSomePattern>(skipNonTypeSyntacticPatterns(p))) {
+      ctx.Diags.diagnose(
+          cond.getIntroducerLoc(),
+          p->isImplicit()
+            ? diag::condition_optional_element_pattern_not_valid_type
+            : diag::optional_element_pattern_not_valid_type,
+         subExpr->getType())
+            .highlight(subExpr->getSourceRange());
+      return;
+    }
+
     ctx.Diags.diagnose(cond.getIntroducerLoc(),
                        diag::optional_check_nonoptional,
                        subExpr->getType())

test/stmt/if_while_var.swift

@@ -23,23 +23,25 @@ if var x = foo() {
 
 use(x) // expected-error{{unresolved identifier 'x'}}
 
-if let x = nonOptionalStruct() { } // expected-error{{initializer for conditional binding must have Optional type, not 'NonOptionalStruct'}}
-if let x = nonOptionalEnum() { } // expected-error{{initializer for conditional binding must have Optional type, not 'NonOptionalEnum'}}
+if let x = nonOptionalStruct() { _ = x} // expected-error{{initializer for conditional binding must have Optional type, not 'NonOptionalStruct'}}
+if let x = nonOptionalEnum() { _ = x} // expected-error{{initializer for conditional binding must have Optional type, not 'NonOptionalEnum'}}
 
 guard let _ = nonOptionalStruct() else { fatalError() } // expected-error{{initializer for conditional binding must have Optional type, not 'NonOptionalStruct'}}
 guard let _ = nonOptionalEnum() else { fatalError() } // expected-error{{initializer for conditional binding must have Optional type, not 'NonOptionalEnum'}}
 
-if case let x? = nonOptionalStruct() { } // expected-error{{'?' pattern cannot match values of type 'NonOptionalStruct'}}
-if case let x? = nonOptionalEnum() { } // expected-error{{'?' pattern cannot match values of type 'NonOptionalEnum'}}
+if case let x? = nonOptionalStruct() { _ = x } // expected-error{{'?' pattern cannot match values of type 'NonOptionalStruct'}}
+if case let x? = nonOptionalEnum() { _ = x } // expected-error{{'?' pattern cannot match values of type 'NonOptionalEnum'}}
 
 class B {} // expected-note * {{did you mean 'B'?}}
 class D : B {}// expected-note * {{did you mean 'D'?}}
 
 // TODO poor recovery in these cases
 if let {} // expected-error {{expected '{' after 'if' condition}} expected-error {{pattern matching in a condition requires the 'case' keyword}}
-if let x = {} // expected-error{{'{' after 'if'}} expected-error {{variable binding in a condition requires an initializer}} expected-error{{initializer for conditional binding must have Optional type, not '() -> ()'}}
+if let x = { } // expected-error{{'{' after 'if'}} expected-error {{variable binding in a condition requires an initializer}} expected-error{{initializer for conditional binding must have Optional type, not '() -> ()'}}
+// expected-warning@-1{{value 'x' was defined but never used}}
 
 if let x = foo() {
+  _ = x
 } else {
   // TODO: more contextual error? "x is only available on the true branch"?
   use(x) // expected-error{{unresolved identifier 'x'}}
@@ -62,8 +64,8 @@ if var x = opt {} // expected-warning {{value 'x' was defined but never used; co
 
 // <rdar://problem/20800015> Fix error message for invalid if-let
 let someInteger = 1
-if let y = someInteger {}  // expected-error {{initializer for conditional binding must have Optional type, not 'Int'}}
-if case let y? = someInteger {}  // expected-error {{'?' pattern cannot match values of type 'Int'}}
+if let y = someInteger { _ = y }  // expected-error {{initializer for conditional binding must have Optional type, not 'Int'}}
+if case let y? = someInteger { _ = y }  // expected-error {{'?' pattern cannot match values of type 'Int'}}
 
 // Test multiple clauses on "if let".
 if let x = opt, let y = opt, x != y,

test/stmt/statements.swift

@@ -554,7 +554,7 @@ func testThrowNil() throws {
 // Even if the condition fails to typecheck, save it in the AST anyway; the old
 // condition may have contained a SequenceExpr.
 func r23684220(_ b: Any) {
-  if let _ = b ?? b {} // expected-error {{initializer for conditional binding must have Optional type, not 'Any'}}
+  if let _ = b ?? b {} // expected-warning {{left side of nil coalescing operator '??' has non-optional type 'Any', so the right side is never used}}
 }