[Function builders] Fake Expr-based locators for now.

The right solution is to extend the notion of the "anchor" of a locator
to also cover statements (and TypeReprs, and Patterns, and more), so
this is a stop-gap.

Author: DougGregor

lib/Sema/BuilderTransform.cpp

@@ -1054,11 +1054,33 @@ Optional<BraceStmt *> TypeChecker::applyFunctionBuilderBodyTransform(
   // Build a constraint system in which we can check the body of the function.
   ConstraintSystem cs(func, options);
 
+  // Find an expression... any expression... to use for a locator.
+  // FIXME: This is a hack because we don't have the notion of locators that
+  // refer to statements.
+  Expr *fakeAnchor = nullptr;
+  {
+    class FindExprWalker : public ASTWalker {
+      Expr *&fakeAnchor;
+
+    public:
+      explicit FindExprWalker(Expr *&fakeAnchor) : fakeAnchor(fakeAnchor) { }
+
+      std::pair<bool, Expr *> walkToExprPre(Expr *E) {
+        if (!fakeAnchor)
+          fakeAnchor = E;
+
+        return { false, nullptr };
+      }
+    } walker(fakeAnchor);
+
+    func->getBody()->walk(walker);
+  }
+
   // FIXME: check the result
   cs.matchFunctionBuilder(func, builderType, resultContextType,
                           resultConstraintKind,
-                          /*calleeLocator=*/nullptr,
-                          /*FIXME:*/ConstraintLocatorBuilder(nullptr));
+                          /*calleeLocator=*/cs.getConstraintLocator(fakeAnchor),
+                          /*FIXME:*/cs.getConstraintLocator(fakeAnchor));
 
   // Solve the constraint system.
   SmallVector<Solution, 4> solutions;

lib/Sema/CSDiagnostics.cpp

@@ -1005,7 +1005,7 @@ void MissingOptionalUnwrapFailure::offerDefaultValueUnwrapFixIt(
   // If anchor is n explicit address-of, or expression which produces
   // an l-value (e.g. first argument of `+=` operator), let's not
   // suggest default value here because that would produce r-value type.
-  if (isa<InOutExpr>(anchor))
+  if (!anchor || isa<InOutExpr>(anchor))
     return;
 
   auto &cs = getConstraintSystem();

lib/Sema/ConstraintSystem.cpp

@@ -3653,13 +3653,14 @@ ConstraintSystem::getFunctionArgApplyInfo(ConstraintLocator *locator) {
       assert(!shouldHaveDirectCalleeOverload(call) &&
              "Should we have resolved a callee for this?");
       rawFnType = getType(call->getFn());
-    } else {
+    } else if (auto *apply = dyn_cast<ApplyExpr>(anchor)) {
       // FIXME: ArgumentMismatchFailure is currently used from CSDiag, meaning
       // we can end up a BinaryExpr here with an unresolved callee. It should be
       // possible to remove this once we've gotten rid of the old CSDiag logic
       // and just assert that we have a CallExpr.
-      auto *apply = cast<ApplyExpr>(anchor);
       rawFnType = getType(apply->getFn());
+    } else {
+      return None;
     }
   }