Merge pull request swiftlang#29595 from DougGregor/generalize-solution-application-target

[Constraint system] Add a SolutionApplicationTarget-based typeCheckExpression

Author: DougGregor

lib/Sema/CSApply.cpp

@@ -7345,6 +7345,13 @@ Optional<SolutionApplicationTarget> ConstraintSystem::applySolution(
     if (!resultExpr)
       return None;
 
+    // For an @autoclosure default parameter type, add the autoclosure
+    // conversion.
+    if (FunctionType *autoclosureParamType =
+            target.getAsAutoclosureParamType()) {
+      resultExpr = buildAutoClosureExpr(resultExpr, autoclosureParamType);
+    }
+
     solution.setExprTypes(resultExpr);
     result.setExpr(resultExpr);
   }

lib/Sema/ConstraintSystem.cpp

@@ -3968,3 +3968,62 @@ ValueDecl *ConstraintSystem::findResolvedMemberRef(ConstraintLocator *locator) {
 
   return choice.getDecl();
 }
+
+SolutionApplicationTarget::SolutionApplicationTarget(
+    Expr *expr, ContextualTypePurpose contextualPurpose,
+    TypeLoc convertType, bool isDiscarded) {
+  // Verify that a purpose was specified if a convertType was.  Note that it is
+  // ok to have a purpose without a convertType (which is used for call
+  // return types).
+  assert((!convertType.getType() || contextualPurpose != CTP_Unused) &&
+         "Purpose for conversion type was not specified");
+
+  // Take a look at the conversion type to check to make sure it is sensible.
+  if (auto type = convertType.getType()) {
+    // If we're asked to convert to an UnresolvedType, then ignore the request.
+    // This happens when CSDiags nukes a type.
+    if (type->is<UnresolvedType>() ||
+        (type->is<MetatypeType>() && type->hasUnresolvedType())) {
+      convertType = TypeLoc();
+      contextualPurpose = CTP_Unused;
+    }
+  }
+
+  kind = Kind::expression;
+  expression.expression = expr;
+  expression.contextualPurpose = contextualPurpose;
+  expression.convertType = convertType;
+  expression.isDiscarded = isDiscarded;
+}
+
+bool SolutionApplicationTarget::contextualTypeIsOnlyAHint(
+    bool isOpaqueReturnType) const {
+  assert(kind == Kind::expression);
+  switch (expression.contextualPurpose) {
+  case CTP_Initialization:
+    return !isOpaqueReturnType;
+  case CTP_ForEachStmt:
+    return true;
+  case CTP_Unused:
+  case CTP_ReturnStmt:
+  case CTP_ReturnSingleExpr:
+  case CTP_YieldByValue:
+  case CTP_YieldByReference:
+  case CTP_ThrowStmt:
+  case CTP_EnumCaseRawValue:
+  case CTP_DefaultParameter:
+  case CTP_AutoclosureDefaultParameter:
+  case CTP_CalleeResult:
+  case CTP_CallArgument:
+  case CTP_ClosureResult:
+  case CTP_ArrayElement:
+  case CTP_DictionaryKey:
+  case CTP_DictionaryValue:
+  case CTP_CoerceOperand:
+  case CTP_AssignSource:
+  case CTP_SubscriptAssignSource:
+  case CTP_Condition:
+  case CTP_CannotFail:
+    return false;
+  }
+}

lib/Sema/ConstraintSystem.h

@@ -1174,13 +1174,7 @@ class SolutionApplicationTarget {
                                   isDiscarded) { }
 
   SolutionApplicationTarget(Expr *expr, ContextualTypePurpose contextualPurpose,
-                            TypeLoc convertType, bool isDiscarded) {
-    kind = Kind::expression;
-    expression.expression = expr;
-    expression.contextualPurpose = contextualPurpose;
-    expression.convertType = convertType;
-    expression.isDiscarded = isDiscarded;
-  }
+                            TypeLoc convertType, bool isDiscarded);
 
   SolutionApplicationTarget(AnyFunctionRef fn)
       : SolutionApplicationTarget(fn, fn.getBody()) { }
@@ -1207,15 +1201,31 @@ class SolutionApplicationTarget {
   }
 
   Type getExprConversionType() const {
-    assert(kind == Kind::expression);
-    return expression.convertType.getType();
+    return getExprConversionTypeLoc().getType();
   }
 
   TypeLoc getExprConversionTypeLoc() const {
     assert(kind == Kind::expression);
+
+    // For an @autoclosure parameter, the conversion type is
+    // the result of the function type.
+    if (FunctionType *autoclosureParamType = getAsAutoclosureParamType()) {
+      return TypeLoc(expression.convertType.getTypeRepr(),
+                     autoclosureParamType->getResult());
+    }
+
     return expression.convertType;
   }
 
+  /// Returns the autoclosure parameter type, or \c nullptr if the
+  /// expression has a different kind of context.
+  FunctionType *getAsAutoclosureParamType() const {
+    assert(kind == Kind::expression);
+    if (expression.contextualPurpose == CTP_AutoclosureDefaultParameter)
+      return expression.convertType.getType()->castTo<FunctionType>();
+    return nullptr;
+  }
+
   void setExprConversionType(Type type) {
     assert(kind == Kind::expression);
     expression.convertType = TypeLoc::withoutLoc(type);
@@ -1226,6 +1236,9 @@ class SolutionApplicationTarget {
     expression.convertType = type;
   }
 
+  /// Whether the contextual type is only a hint, rather than a type
+  bool contextualTypeIsOnlyAHint(bool isOpaqueReturnType) const;
+
   bool isDiscardedExpr() const {
     assert(kind == Kind::expression);
     return expression.isDiscarded;

lib/Sema/TypeCheckConstraints.cpp

@@ -2001,55 +2001,54 @@ bool GenericRequirementsCheckListener::diagnoseUnsatisfiedRequirement(
   return false;
 }
 
-/// Whether the contextual type provided for the given purpose is only a
-/// hint, and not a requirement.
-static bool contextualTypeIsOnlyAHint(ContextualTypePurpose ctp,
-                                      TypeCheckExprOptions options) {
-  switch (ctp) {
-  case CTP_Initialization:
-    return !options.contains(
-        TypeCheckExprFlags::ConvertTypeIsOpaqueReturnType);
-  case CTP_ForEachStmt:
-    return true;
-  case CTP_Unused:
-  case CTP_ReturnStmt:
-  case CTP_ReturnSingleExpr:
-  case CTP_YieldByValue:
-  case CTP_YieldByReference:
-  case CTP_ThrowStmt:
-  case CTP_EnumCaseRawValue:
-  case CTP_DefaultParameter:
-  case CTP_AutoclosureDefaultParameter:
-  case CTP_CalleeResult:
-  case CTP_CallArgument:
-  case CTP_ClosureResult:
-  case CTP_ArrayElement:
-  case CTP_DictionaryKey:
-  case CTP_DictionaryValue:
-  case CTP_CoerceOperand:
-  case CTP_AssignSource:
-  case CTP_SubscriptAssignSource:
-  case CTP_Condition:
-  case CTP_CannotFail:
-    return false;
-  }
-}
-
 #pragma mark High-level entry points
 Type TypeChecker::typeCheckExpression(Expr *&expr, DeclContext *dc,
                                       TypeLoc convertType,
                                       ContextualTypePurpose convertTypePurpose,
                                       TypeCheckExprOptions options,
                                       ExprTypeCheckListener *listener,
                                       ConstraintSystem *baseCS) {
+  SolutionApplicationTarget target(
+      expr, convertTypePurpose, convertType,
+      options.contains(TypeCheckExprFlags::IsDiscarded));
+  bool unresolvedTypeExprs = false;
+  auto resultTarget = typeCheckExpression(
+      target, dc, unresolvedTypeExprs, options, listener, baseCS);
+  if (!resultTarget) {
+    expr = target.getAsExpr();
+    return Type();
+  }
+
+  expr = resultTarget->getAsExpr();
+
+  // HACK for clients that want unresolved types.
+  if (unresolvedTypeExprs) {
+    return ErrorType::get(dc->getASTContext());
+  }
+
+
+  return expr->getType();
+}
+
+Optional<SolutionApplicationTarget>
+TypeChecker::typeCheckExpression(
+    SolutionApplicationTarget &target,
+    DeclContext *dc,
+    bool &unresolvedTypeExprs,
+    TypeCheckExprOptions options,
+    ExprTypeCheckListener *listener,
+    ConstraintSystem *baseCS) {
+  unresolvedTypeExprs = false;
   auto &Context = dc->getASTContext();
+  Expr *expr = target.getAsExpr();
   FrontendStatsTracer StatsTracer(Context.Stats, "typecheck-expr", expr);
   PrettyStackTraceExpr stackTrace(Context, "type-checking", expr);
 
   // First, pre-check the expression, validating any types that occur in the
   // expression and folding sequence expressions.
   if (ConstraintSystem::preCheckExpression(expr, dc, baseCS)) {
-    return Type();
+    target.setExpr(expr);
+    return None;
   }
 
   // Construct a constraint system from this expression.
@@ -2067,45 +2066,23 @@ Type TypeChecker::typeCheckExpression(Expr *&expr, DeclContext *dc,
   ConstraintSystem cs(dc, csOptions);
   cs.baseCS = baseCS;
 
-  // Verify that a purpose was specified if a convertType was.  Note that it is
-  // ok to have a purpose without a convertType (which is used for call
-  // return types).
-  assert((!convertType.getType() || convertTypePurpose != CTP_Unused) &&
-         "Purpose for conversion type was not specified");
-
-  // Take a look at the conversion type to check to make sure it is sensible.
-  if (auto type = convertType.getType()) {
-    // If we're asked to convert to an UnresolvedType, then ignore the request.
-    // This happens when CSDiags nukes a type.
-    if (type->is<UnresolvedType>() ||
-        (type->is<MetatypeType>() && type->hasUnresolvedType())) {
-      convertType = TypeLoc();
-      convertTypePurpose = CTP_Unused;
-    }
-  }
-
-  // For an @autoclosure default parameter, we want to convert to the result
-  // type. Stash the autoclosure default parameter type.
-  FunctionType *autoclosureDefaultParamType = nullptr;
-  if (convertTypePurpose == CTP_AutoclosureDefaultParameter) {
-    autoclosureDefaultParamType = convertType.getType()->castTo<FunctionType>();
-    convertType.setType(autoclosureDefaultParamType->getResult());
-  }
-
   // Tell the constraint system what the contextual type is.  This informs
   // diagnostics and is a hint for various performance optimizations.
   // FIXME: Look through LoadExpr. This is an egregious hack due to the
   // way typeCheckExprIndependently works.
+  TypeLoc convertType = target.getExprConversionTypeLoc();
   Expr *contextualTypeExpr = expr;
   if (auto loadExpr = dyn_cast_or_null<LoadExpr>(contextualTypeExpr))
     contextualTypeExpr = loadExpr->getSubExpr();
   cs.setContextualType(
-      contextualTypeExpr, convertType, convertTypePurpose,
+      contextualTypeExpr, convertType,
+      target.getExprContextualTypePurpose(),
       options.contains(TypeCheckExprFlags::ConvertTypeIsOpaqueReturnType));
 
   // If the convertType is *only* provided for that hint, then null it out so
   // that we don't later treat it as an actual conversion constraint.
-  if (contextualTypeIsOnlyAHint(convertTypePurpose, options))
+  if (target.contextualTypeIsOnlyAHint(
+          options.contains(TypeCheckExprFlags::ConvertTypeIsOpaqueReturnType)))
     convertType = TypeLoc();
 
   // If the client can handle unresolved type variables, leave them in the
@@ -2122,56 +2099,59 @@ Type TypeChecker::typeCheckExpression(Expr *&expr, DeclContext *dc,
         cs.getConstraintLocator(expr, LocatorPathElt::ContextualType());
     Type var = cs.createTypeVariable(convertTypeLocator, TVO_CanBindToNoEscape);
     convertTo = getOptionalType(expr->getLoc(), var);
+  } else if (target.getExprContextualTypePurpose()
+                 == CTP_AutoclosureDefaultParameter) {
+    // FIXME: Hack around the convertTo adjustment below, which we want to
+    // eliminate.
+    convertTo = Type(target.getAsAutoclosureParamType());
   }
 
   // Attempt to solve the constraint system.
-  SolutionApplicationTarget target(
-      expr, convertTypePurpose, convertTo,
-      options.contains(TypeCheckExprFlags::IsDiscarded));
-  auto viable = cs.solve(target, listener, allowFreeTypeVariables);
-  if (!viable)
-    return Type();
+  SolutionApplicationTarget innerTarget(
+      expr, target.getExprContextualTypePurpose(), convertTo,
+      target.isDiscardedExpr());
+  auto viable = cs.solve(innerTarget, listener, allowFreeTypeVariables);
+  if (!viable) {
+    target.setExpr(expr);
+    return None;
+  }
 
   // If the client allows the solution to have unresolved type expressions,
   // check for them now.  We cannot apply the solution with unresolved TypeVars,
   // because they will leak out into arbitrary places in the resultant AST.
   if (options.contains(TypeCheckExprFlags::AllowUnresolvedTypeVariables) &&
        (viable->size() != 1 ||
        (convertType.getType() && convertType.getType()->hasUnresolvedType()))) {
-    return ErrorType::get(Context);
+    // FIXME: This hack should only be needed for CSDiag.
+    unresolvedTypeExprs = true;
+    return target;
   }
 
-  auto result = target.getAsExpr();
-  auto &solution = (*viable)[0];
-  if (!result)
-    return Type();
-
   // Apply this solution to the constraint system.
+  // FIXME: This shouldn't be necessary.
+  auto &solution = (*viable)[0];
   cs.applySolution(solution);
 
   // Apply the solution to the expression.
   bool performingDiagnostics =
       options.contains(TypeCheckExprFlags::SubExpressionDiagnostics);
-  // FIXME: HACK!
-  target.setExprConversionType(convertType.getType());
+  // FIXME: HACK! Copy over the inner target's expression info.
+  target.setExpr(innerTarget.getAsExpr());
+  if (convertTo.isNull())
+    target.setExprConversionType(convertTo);
   auto resultTarget = cs.applySolution(solution, target, performingDiagnostics);
   if (!resultTarget) {
     // Failure already diagnosed, above, as part of applying the solution.
-    return Type();
-  }
-  result = resultTarget->getAsExpr();
-
-  // For an @autoclosure default parameter type, add the autoclosure
-  // conversion.
-  if (convertTypePurpose == CTP_AutoclosureDefaultParameter) {
-    result = cs.buildAutoClosureExpr(result, autoclosureDefaultParamType);
+    return None;
   }
+  Expr *result = resultTarget->getAsExpr();
 
   // Notify listener that we've applied the solution.
-  if (listener)
+  if (listener) {
     result = listener->appliedSolution(solution, result);
-  if (!result)
-    return Type();
+    if (!result)
+      return None;
+  }
 
   if (Context.TypeCheckerOpts.DebugConstraintSolver) {
     auto &log = Context.TypeCheckerDebug->getStream();
@@ -2188,8 +2168,8 @@ Type TypeChecker::typeCheckExpression(Expr *&expr, DeclContext *dc,
     performSyntacticExprDiagnostics(result, dc, isExprStmt);
   }
 
-  expr = result;
-  return cs.getType(expr);
+  target.setExpr(result);
+  return target;
 }
 
 Type TypeChecker::typeCheckParameterDefault(Expr *&defaultValue,

lib/Sema/TypeChecker.h

@@ -49,6 +49,7 @@ namespace constraints {
   enum class ConstraintKind : char;
   class ConstraintSystem;
   class Solution;
+  class SolutionApplicationTarget;
   class SolutionResult;
 }
 
@@ -832,6 +833,14 @@ class TypeChecker final {
                       ExprTypeCheckListener *listener = nullptr,
                       constraints::ConstraintSystem *baseCS = nullptr);
 
+  static Optional<constraints::SolutionApplicationTarget>
+  typeCheckExpression(constraints::SolutionApplicationTarget &target,
+                      DeclContext *dc,
+                      bool &unresolvedTypeExprs,
+                      TypeCheckExprOptions options = TypeCheckExprOptions(),
+                      ExprTypeCheckListener *listener = nullptr,
+                      constraints::ConstraintSystem *baseCS = nullptr);
+
   /// Type check the given expression and return its type without
   /// applying the solution.
   ///