[CodeComplete] Improve ExpectsNonVoid computation

If we know we have a Void expected type, don't set
`ExpectsNonVoid` to `true`.

Author: hamishknight

lib/IDE/PostfixCompletion.cpp

@@ -189,23 +189,27 @@ void PostfixCompletionCallback::sawSolutionImpl(
 
   bool BaseIsStaticMetaType = S.isStaticallyDerivedMetatype(ParsedExpr);
 
+  bool ExpectsNonVoid = false;
   SmallVector<Type, 4> ExpectedTypes;
   if (ExpectedTy) {
     ExpectedTypes.push_back(ExpectedTy);
-  }
-
-  bool ExpectsNonVoid = false;
-  ExpectsNonVoid |= ExpectedTy && !ExpectedTy->isVoid();
-  ExpectsNonVoid |=
-      !ParentExpr && CS.getContextualTypePurpose(CompletionExpr) != CTP_Unused;
-
-  for (auto SAT : S.targets) {
-    if (ExpectsNonVoid) {
-      // ExpectsNonVoid is already set. No need to iterate further.
-      break;
-    }
-    if (SAT.second.getAsExpr() == CompletionExpr) {
-      ExpectsNonVoid |= SAT.second.getExprContextualTypePurpose() != CTP_Unused;
+    ExpectsNonVoid = !ExpectedTy->isVoid();
+  } else {
+    // If we don't know what the expected type is, assume it must be non-Void
+    // if we have a contextual type that is not unused. This prevents us from
+    // suggesting Void values for e.g bindings without explicit types.
+    ExpectsNonVoid |= !ParentExpr &&
+                      CS.getContextualTypePurpose(CompletionExpr) != CTP_Unused;
+
+    for (auto SAT : S.targets) {
+      if (ExpectsNonVoid) {
+        // ExpectsNonVoid is already set. No need to iterate further.
+        break;
+      }
+      if (SAT.second.getAsExpr() == CompletionExpr) {
+        ExpectsNonVoid |=
+            SAT.second.getExprContextualTypePurpose() != CTP_Unused;
+      }
     }
   }
 

test/IDE/complete_single_expression_return.swift

@@ -128,6 +128,55 @@ struct TestSingleExprClosureGlobal {
 // TestSingleExprClosureGlobal-DAG: Decl[InstanceMethod]/CurrNominal: void()[#Void#];
 }
 
+struct TestSingleExprClosureBinding {
+  func void() -> Void {}
+  func str() -> String { return "" }
+  func int() -> Int { return 0 }
+
+  func test() -> Int {
+    let fn = {
+      self.#^TestSingleExprClosureBinding^#
+    }
+    return fn()
+  }
+// Void is always valid in an implicit single expr closure.
+// TestSingleExprClosureBinding-DAG: Decl[InstanceMethod]/CurrNominal: str()[#String#];
+// TestSingleExprClosureBinding-DAG: Decl[InstanceMethod]/CurrNominal: int()[#Int#];
+// TestSingleExprClosureBinding-DAG: Decl[InstanceMethod]/CurrNominal: void()[#Void#];
+}
+
+struct TestExplicitSingleExprClosureBinding {
+  func void() -> Void {}
+  func str() -> String { return "" }
+  func int() -> Int { return 0 }
+
+  func test() {
+    let fn = {
+      return self.#^TestExplicitSingleExprClosureBinding^#
+    }
+  }
+// FIXME: Because we have an explicit return, and no expected type, we shouldn't suggest Void.
+// TestExplicitSingleExprClosureBinding-DAG: Decl[InstanceMethod]/CurrNominal: str()[#String#];
+// TestExplicitSingleExprClosureBinding-DAG: Decl[InstanceMethod]/CurrNominal: int()[#Int#];
+// TestExplicitSingleExprClosureBinding-DAG: Decl[InstanceMethod]/CurrNominal: void()[#Void#];
+}
+
+struct TestExplicitSingleExprClosureBindingWithContext {
+  func void() -> Void {}
+  func str() -> String { return "" }
+  func int() -> Int { return 0 }
+
+  func test() {
+    let fn: () -> Void = {
+      return self.#^TestExplicitSingleExprClosureBindingWithContext^#
+    }
+  }
+// We know Void is valid.
+// TestExplicitSingleExprClosureBindingWithContext-DAG: Decl[InstanceMethod]/CurrNominal: str()[#String#];
+// TestExplicitSingleExprClosureBindingWithContext-DAG: Decl[InstanceMethod]/CurrNominal: int()[#Int#];
+// TestExplicitSingleExprClosureBindingWithContext-DAG: Decl[InstanceMethod]/CurrNominal/TypeRelation[Convertible]: void()[#Void#];
+}
+
 struct TestNonSingleExprClosureGlobal {
   func void() -> Void {}
   func str() -> String { return "" }
@@ -190,6 +239,21 @@ struct TestSingleExprFunc {
 // TestSingleExprFunc-DAG: Decl[InstanceMethod]/CurrNominal: void()[#Void#];
 }
 
+struct TestSingleExprFuncReturnVoid {
+  func void() -> Void {}
+  func str() -> String { return "" }
+  func int() -> Int { return 0 }
+
+  func test() {
+    return self.#^TestSingleExprFuncReturnVoid^#
+  }
+
+// Void is the only possible type that can be used here.
+// TestSingleExprFuncReturnVoid-DAG: Decl[InstanceMethod]/CurrNominal: str()[#String#];
+// TestSingleExprFuncReturnVoid-DAG: Decl[InstanceMethod]/CurrNominal: int()[#Int#];
+// TestSingleExprFuncReturnVoid-DAG: Decl[InstanceMethod]/CurrNominal/TypeRelation[Convertible]: void()[#Void#];
+}
+
 struct TestSingleExprFuncUnresolved {
   enum MyEnum { case myEnum }
   enum NotMine { case notMine }