[ConstraintSystem] Implement uninitialized pattern binding support

This like `let x: Int` or `let (x, y), ...` are now supported by
the constraint solver.

Author: xedin

lib/Sema/CSApply.cpp

@@ -8795,7 +8795,10 @@ ExprWalker::rewriteTarget(SolutionApplicationTarget target) {
       patternBinding->setPattern(
           index, resultTarget->getInitializationPattern(),
           resultTarget->getDeclContext());
-      patternBinding->setInit(index, resultTarget->getAsExpr());
+
+      if (patternBinding->getInit(index)) {
+        patternBinding->setInit(index, resultTarget->getAsExpr());
+      }
     }
 
     return target;
@@ -8810,6 +8813,21 @@ ExprWalker::rewriteTarget(SolutionApplicationTarget target) {
         wrappedVar, backingType->mapTypeOutOfContext());
 
     return target;
+  } else if (auto *pattern = target.getAsUninitializedVar()) {
+    auto contextualPattern = target.getContextualPattern();
+    auto patternType = target.getTypeOfUninitializedVar();
+
+    TypeResolutionOptions options = TypeResolverContext::PatternBindingDecl;
+    options |= TypeResolutionFlags::OverrideType;
+
+    if (auto coercedPattern = TypeChecker::coercePatternToType(
+            contextualPattern, patternType, options)) {
+      auto resultTarget = target;
+      resultTarget.setPattern(coercedPattern);
+      return resultTarget;
+    }
+
+    return None;
   } else {
     auto fn = *target.getAsFunction();
     if (rewriteFunction(fn))

lib/Sema/CSGen.cpp

@@ -3935,14 +3935,13 @@ bool ConstraintSystem::generateConstraints(
         return true;
 
       auto init = patternBinding->getInit(index);
-      if (!init) {
-        llvm_unreachable("Unsupported pattern binding entry");
-      }
 
-      // Generate constraints for the initialization.
-      auto target = SolutionApplicationTarget::forInitialization(
-          init, dc, patternType, pattern,
-          /*bindPatternVarsOneWay=*/true);
+      auto target = init ? SolutionApplicationTarget::forInitialization(
+                               init, dc, patternType, pattern,
+                               /*bindPatternVarsOneWay=*/true)
+                         : SolutionApplicationTarget::forUninitializedVar(
+                               patternBinding, index, pattern, patternType);
+
       if (generateConstraints(target, FreeTypeVariableBinding::Disallow)) {
         hadError = true;
         continue;
@@ -3963,9 +3962,20 @@ bool ConstraintSystem::generateConstraints(
 
       return generateWrappedPropertyTypeConstraints(
         *this, /*initializerType=*/Type(), wrappedVar, propertyType);
-    }
+    } else {
+      auto pattern = target.getAsUninitializedVar();
+      auto locator = getConstraintLocator(
+          pattern, LocatorPathElt::ContextualType(CTP_Initialization));
+
+      // Generate constraints to bind all of the internal declarations
+      // and verify the pattern.
+      Type patternType = generateConstraints(
+          pattern, locator, /*shouldBindPatternVarsOneWay*/ true,
+          target.getPatternBindingOfUninitializedVar(),
+          target.getIndexOfUninitializedVar());
 
-    llvm_unreachable("Unsupported un-initialized variable");
+      return !patternType;
+    }
   }
   }
 }

lib/Sema/ConstraintSystem.cpp

@@ -5438,6 +5438,12 @@ SolutionApplicationTarget::forPropertyWrapperInitializer(
 
 ContextualPattern
 SolutionApplicationTarget::getContextualPattern() const {
+  if (kind == Kind::uninitializedVar) {
+    assert(patternBinding);
+    return ContextualPattern::forPatternBindingDecl(patternBinding,
+                                                    uninitializedVar.index);
+  }
+
   assert(kind == Kind::expression);
   assert(expression.contextualPurpose == CTP_Initialization ||
          expression.contextualPurpose == CTP_ForEachStmt);
@@ -5553,6 +5559,8 @@ void ConstraintSystem::diagnoseFailureFor(SolutionApplicationTarget target) {
       nominal->diagnose(diag::property_wrapper_declared_here,
                         nominal->getName());
     }
+  } else if (auto *var = target.getAsUninitializedVar()) {
+    DE.diagnose(target.getLoc(), diag::failed_to_produce_diagnostic);
   } else {
     // Emit a poor fallback message.
     DE.diagnose(target.getAsFunction()->getLoc(),