[CSClosure] Declarations prefixed with $ can act as inferrable placeholders

If the type for such declaration could be completely inferred it
would be used during solution application. This is used to infer
types for result builder components.

Author: xedin

lib/Sema/CSApply.cpp

@@ -9045,12 +9045,23 @@ ExprWalker::rewriteTarget(SolutionApplicationTarget target) {
 
     return target;
   } else if (auto *pattern = target.getAsUninitializedVar()) {
+    TypeResolutionOptions options(TypeResolverContext::PatternBindingDecl);
+
     auto contextualPattern = target.getContextualPattern();
     auto patternType = target.getTypeOfUninitializedVar();
+    auto *PB = target.getPatternBindingOfUninitializedVar();
+
+    // If this is a placeholder variable, let's override its type with
+    // inferred one.
+    if (auto *var = PB->getSingleVar()) {
+      if (var->getName().hasDollarPrefix() && patternType->hasPlaceholder()) {
+        patternType = solution.getResolvedType(var);
+        options |= TypeResolutionFlags::OverrideType;
+      }
+    }
 
     if (auto coercedPattern = TypeChecker::coercePatternToType(
-            contextualPattern, patternType,
-            TypeResolverContext::PatternBindingDecl)) {
+            contextualPattern, patternType, options)) {
       auto resultTarget = target;
       resultTarget.setPattern(coercedPattern);
       return resultTarget;

lib/Sema/CSClosure.cpp

@@ -85,6 +85,30 @@ class TypeVariableRefFinder : public ASTWalker {
         }
 
         inferVariables(type);
+        return {true, expr};
+      }
+
+      auto var = dyn_cast<VarDecl>(decl);
+      if (!var)
+        return {true, expr};
+
+      // If there is no type recorded yet, let's check whether
+      // it is a placeholder variable implicitly generated by the
+      // compiler.
+      if (var->getName().hasDollarPrefix()) {
+        if (auto *PB = var->getParentPatternBinding()) {
+          auto patternTarget = CS.getSolutionApplicationTarget({PB, 0});
+          if (!patternTarget)
+            return {true, expr};
+
+          auto patternType = patternTarget->getTypeOfUninitializedVar();
+          if (patternType->hasPlaceholder()) {
+            auto openedTy = CS.replaceInferableTypesWithTypeVars(
+                patternType, CS.getConstraintLocator(expr));
+            inferVariables(openedTy);
+            CS.setType(var, openedTy);
+          }
+        }
       }
     }
 
@@ -521,14 +545,26 @@ class SyntacticElementConstraintGenerator
     }
 
     auto target = getTargetForPattern(patternBinding, index, patternType);
-    if (!target ||
-        cs.generateConstraints(*target, FreeTypeVariableBinding::Disallow)) {
+    if (!target) {
       hadError = true;
       return;
     }
 
     // Keep track of this binding entry.
     cs.setSolutionApplicationTarget({patternBinding, index}, *target);
+
+    if (patternType->hasPlaceholder()) {
+      if (auto *var = patternBinding->getSingleVar()) {
+        if (var->getName().hasDollarPrefix() &&
+            !patternBinding->isExplicitlyInitialized(index))
+          return;
+      }
+    }
+
+    if (cs.generateConstraints(*target, FreeTypeVariableBinding::Disallow)) {
+      hadError = true;
+      return;
+    }
   }
 
   void visitDecl(Decl *decl) {

lib/Sema/ConstraintSystem.cpp

@@ -894,6 +894,18 @@ Type ConstraintSystem::replaceInferableTypesWithTypeVars(
               TVO_CanBindToNoEscape | TVO_PrefersSubtypeBinding |
                   TVO_CanBindToHole);
         }
+
+        if (auto *var = placeholderTy->getOriginator().dyn_cast<VarDecl *>()) {
+          if (var->getName().hasDollarPrefix()) {
+            auto *repr =
+                new (type->getASTContext()) PlaceholderTypeRepr(var->getLoc());
+            return createTypeVariable(
+                getConstraintLocator(locator,
+                                     LocatorPathElt::PlaceholderType(repr)),
+                TVO_CanBindToNoEscape | TVO_PrefersSubtypeBinding |
+                    TVO_CanBindToHole);
+          }
+        }
       }
 
       return type;