[Constraint system] Simplify creation of contextual conversion constraint.

DougGregor · DougGregor · commit bbc0a95723d2 · 2020-02-03T22:38:24.000-08:00
We were storing more state than necessary in the constraint system.
diff --git a/lib/Sema/CSGen.cpp b/lib/Sema/CSGen.cpp
@@ -3831,8 +3831,7 @@ bool ConstraintSystem::generateConstraints(StmtCondition condition,
 
     case StmtConditionElement::CK_Boolean: {
       Expr *condExpr = condElement.getBoolean();
-      setContextualType(condExpr, TypeLoc::withoutLoc(boolTy), CTP_Condition,
-                        /*isOpaqueReturnType=*/false);
+      setContextualType(condExpr, TypeLoc::withoutLoc(boolTy), CTP_Condition);
 
       condExpr = generateConstraints(condExpr, dc);
       if (!condExpr) {
diff --git a/lib/Sema/CSSimplify.cpp b/lib/Sema/CSSimplify.cpp
@@ -9095,57 +9095,57 @@ void ConstraintSystem::addConstraint(ConstraintKind kind, Type first,
 }
 
 void ConstraintSystem::addContextualConversionConstraint(
-    Expr *expr, ContextualTypeInfo contextualType) {
-  Type convertType = contextualType.getType();
-  if (convertType.isNull())
+    Expr *expr, Type conversionType, ContextualTypePurpose purpose,
+    bool isOpaqueReturnType) {
+  if (conversionType.isNull())
     return;
 
   // Determine the type of the constraint.
   auto constraintKind = ConstraintKind::Conversion;
-  switch (contextualType.purpose) {
-    case CTP_ReturnStmt:
-    case CTP_ReturnSingleExpr:
-    case CTP_Initialization:
-      if (contextualType.isOpaqueReturnType)
-        constraintKind = ConstraintKind::OpaqueUnderlyingType;
-      break;
+  switch (purpose) {
+  case CTP_ReturnStmt:
+  case CTP_ReturnSingleExpr:
+  case CTP_Initialization:
+    if (isOpaqueReturnType)
+      constraintKind = ConstraintKind::OpaqueUnderlyingType;
+    break;
 
-    case CTP_CallArgument:
-      constraintKind = ConstraintKind::ArgumentConversion;
-      break;
+  case CTP_CallArgument:
+    constraintKind = ConstraintKind::ArgumentConversion;
+    break;
 
-    case CTP_YieldByReference:
-      // In a by-reference yield, we expect the contextual type to be an
-      // l-value type, so the result must be bound to that.
-      constraintKind = ConstraintKind::Bind;
-      break;
+  case CTP_YieldByReference:
+    // In a by-reference yield, we expect the contextual type to be an
+    // l-value type, so the result must be bound to that.
+    constraintKind = ConstraintKind::Bind;
+    break;
 
-    case CTP_ArrayElement:
-    case CTP_AssignSource:
-    case CTP_CalleeResult:
-    case CTP_CannotFail:
-    case CTP_Condition:
-    case CTP_Unused:
-    case CTP_YieldByValue:
-    case CTP_ThrowStmt:
-    case CTP_EnumCaseRawValue:
-    case CTP_DefaultParameter:
-    case CTP_AutoclosureDefaultParameter:
-    case CTP_ClosureResult:
-    case CTP_DictionaryKey:
-    case CTP_DictionaryValue:
-    case CTP_CoerceOperand:
-    case CTP_SubscriptAssignSource:
-    case CTP_ForEachStmt:
-      break;
+  case CTP_ArrayElement:
+  case CTP_AssignSource:
+  case CTP_CalleeResult:
+  case CTP_CannotFail:
+  case CTP_Condition:
+  case CTP_Unused:
+  case CTP_YieldByValue:
+  case CTP_ThrowStmt:
+  case CTP_EnumCaseRawValue:
+  case CTP_DefaultParameter:
+  case CTP_AutoclosureDefaultParameter:
+  case CTP_ClosureResult:
+  case CTP_DictionaryKey:
+  case CTP_DictionaryValue:
+  case CTP_CoerceOperand:
+  case CTP_SubscriptAssignSource:
+  case CTP_ForEachStmt:
+    break;
   }
 
   // Add the constraint.
-  bool isForSingleExprFunction = (contextualType.purpose == CTP_ReturnSingleExpr);
+  bool isForSingleExprFunction = (purpose == CTP_ReturnSingleExpr);
   auto *convertTypeLocator = getConstraintLocator(
       expr, LocatorPathElt::ContextualType(isForSingleExprFunction));
-  addConstraint(constraintKind, getType(expr), convertType,
-               convertTypeLocator, /*isFavored*/ true);
+  addConstraint(constraintKind, getType(expr), conversionType,
+                convertTypeLocator, /*isFavored*/ true);
 }
 
 Type ConstraintSystem::addJoinConstraint(
diff --git a/lib/Sema/CSSolver.cpp b/lib/Sema/CSSolver.cpp
@@ -240,8 +240,7 @@ void ConstraintSystem::applySolution(const Solution &solution) {
   for (const auto &contextualType : solution.contextualTypes) {
     if (!getContextualTypeInfo(contextualType.first)) {
       setContextualType(contextualType.first, contextualType.second.typeLoc,
-                        contextualType.second.purpose,
-                        contextualType.second.isOpaqueReturnType);
+                        contextualType.second.purpose);
     }
   }
 
@@ -1243,8 +1242,6 @@ ConstraintSystem::solveImpl(SolutionApplicationTarget &target,
   Expr *expr = target.getAsExpr();
   Timer.emplace(expr, *this);
 
-  Expr *origExpr = expr;
-
   // Try to shrink the system by reducing disjunction domains. This
   // goes through every sub-expression and generate its own sub-system, to
   // try to reduce the domains of those subexpressions.
@@ -1277,9 +1274,8 @@ ConstraintSystem::solveImpl(SolutionApplicationTarget &target,
       });
     }
 
-    ContextualTypeInfo info{
-        TypeLoc::withoutLoc(convertType), ctp, isOpaqueReturnType};
-    addContextualConversionConstraint(expr, info);
+    addContextualConversionConstraint(expr, convertType, ctp,
+                                      isOpaqueReturnType);
   }
 
   // Notify the listener that we've built the constraint system.
diff --git a/lib/Sema/ConstraintSystem.h b/lib/Sema/ConstraintSystem.h
@@ -792,7 +792,6 @@ using OpenedTypeMap =
 struct ContextualTypeInfo {
   TypeLoc typeLoc;
   ContextualTypePurpose purpose;
-  bool isOpaqueReturnType = false;
 
   Type getType() const { return typeLoc.getType(); }
 };
@@ -2336,12 +2335,11 @@ class ConstraintSystem {
   }
 
   void setContextualType(
-      const Expr *expr, TypeLoc T, ContextualTypePurpose purpose,
-       bool isOpaqueReturnType) {
+      const Expr *expr, TypeLoc T, ContextualTypePurpose purpose) {
     assert(expr != nullptr && "Expected non-null expression!");
     assert(contextualTypes.count(expr) == 0 &&
            "Already set this contextual type");
-    contextualTypes[expr] = { T, purpose, isOpaqueReturnType };
+    contextualTypes[expr] = { T, purpose };
   }
 
   Optional<ContextualTypeInfo> getContextualTypeInfo(const Expr *expr) const {
@@ -2573,7 +2571,8 @@ class ConstraintSystem {
 
   /// Add the appropriate constraint for a contextual conversion.
   void addContextualConversionConstraint(
-      Expr *expr, ContextualTypeInfo contextualType);
+      Expr *expr, Type conversionType, ContextualTypePurpose purpose,
+      bool isOpaqueReturnType);
 
   /// Add a "join" constraint between a set of types, producing the common
   /// supertype.
diff --git a/lib/Sema/TypeCheckConstraints.cpp b/lib/Sema/TypeCheckConstraints.cpp
@@ -2134,8 +2134,7 @@ TypeChecker::typeCheckExpression(
   cs.setContextualType(
       contextualTypeExpr,
       target.getExprContextualTypeLoc(),
-      target.getExprContextualTypePurpose(),
-      target.infersOpaqueReturnType());
+      target.getExprContextualTypePurpose());
 
   // If the client can handle unresolved type variables, leave them in the
   // system.
