[Constraint system] Eliminate global flag UnderlyingTypeForOpaqueReturnType

Make this information contextual (per type) rather than global (per
constraint system) so we don’t misapply it.

Author: DougGregor

lib/Sema/CSGen.cpp

@@ -3831,7 +3831,8 @@ bool ConstraintSystem::generateConstraints(StmtCondition condition,
 
     case StmtConditionElement::CK_Boolean: {
       Expr *condExpr = condElement.getBoolean();
-      setContextualType(condExpr, TypeLoc::withoutLoc(boolTy), CTP_Condition);
+      setContextualType(condExpr, TypeLoc::withoutLoc(boolTy), CTP_Condition,
+                        /*isOpaqueReturnType=*/false);
 
       condExpr = generateConstraints(condExpr, dc);
       if (!condExpr) {

lib/Sema/CSSimplify.cpp

@@ -9076,9 +9076,7 @@ void ConstraintSystem::addContextualConversionConstraint(
     case CTP_ReturnStmt:
     case CTP_ReturnSingleExpr:
     case CTP_Initialization:
-      // FIXME: This option should not be global!
-      if (Options.contains(
-            ConstraintSystemFlags::UnderlyingTypeForOpaqueReturnType))
+      if (contextualType.isOpaqueReturnType)
         constraintKind = ConstraintKind::OpaqueUnderlyingType;
       break;
 

lib/Sema/CSSolver.cpp

@@ -240,7 +240,8 @@ 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.purpose,
+                        contextualType.second.isOpaqueReturnType);
     }
   }
 
@@ -1239,7 +1240,13 @@ ConstraintSystem::solveImpl(Expr *&expr,
   // If there is a type that we're expected to convert to, add the conversion
   // constraint.
   if (convertType) {
-    auto ctp = getContextualTypePurpose(origExpr);
+    // Determine whether we know more about the contextual type.
+    ContextualTypePurpose ctp = CTP_Unused;
+    bool isOpaqueReturnType = false;
+    if (auto contextualInfo = getContextualTypeInfo(origExpr)) {
+      ctp = contextualInfo->purpose;
+      isOpaqueReturnType = contextualInfo->isOpaqueReturnType;
+    }
 
     // Substitute type variables in for unresolved types.
     if (allowFreeTypeVariables == FreeTypeVariableBinding::UnresolvedType) {
@@ -1254,7 +1261,8 @@ ConstraintSystem::solveImpl(Expr *&expr,
       });
     }
 
-    ContextualTypeInfo info{TypeLoc::withoutLoc(convertType), ctp};
+    ContextualTypeInfo info{
+        TypeLoc::withoutLoc(convertType), ctp, isOpaqueReturnType};
     addContextualConversionConstraint(expr, info);
   }
 

lib/Sema/ConstraintSystem.h

@@ -792,6 +792,7 @@ using OpenedTypeMap =
 struct ContextualTypeInfo  {
   TypeLoc typeLoc;
   ContextualTypePurpose purpose;
+  bool isOpaqueReturnType = false;
 
   Type getType() const { return typeLoc.getType(); }
 };
@@ -1012,10 +1013,6 @@ enum class ConstraintSystemFlags {
   /// expression, and doesn't dig into its subexpressions.
   ReusePrecheckedType = 0x20,
 
-  /// If set, the top-level expression may be able to provide an underlying
-  /// type for the contextual opaque archetype.
-  UnderlyingTypeForOpaqueReturnType = 0x40,
-
   /// FIXME(diagnostics): Once diagnostics are completely switched to new
   /// framework, this flag could be removed as obsolete.
   ///
@@ -2180,11 +2177,12 @@ class ConstraintSystem {
   }
 
   void setContextualType(
-      const Expr *expr, TypeLoc T, ContextualTypePurpose purpose) {
+      const Expr *expr, TypeLoc T, ContextualTypePurpose purpose,
+       bool isOpaqueReturnType) {
     assert(expr != nullptr && "Expected non-null expression!");
     assert(contextualTypes.count(expr) == 0 &&
            "Already set this contextual type");
-    contextualTypes[expr] = { T, purpose };
+    contextualTypes[expr] = { T, purpose, isOpaqueReturnType };
   }
 
   Optional<ContextualTypeInfo> getContextualTypeInfo(const Expr *expr) const {

lib/Sema/TypeCheckConstraints.cpp

@@ -2189,9 +2189,6 @@ Type TypeChecker::typeCheckExpressionImpl(Expr *&expr, DeclContext *dc,
   if (options.contains(TypeCheckExprFlags::AllowUnresolvedTypeVariables))
     csOptions |= ConstraintSystemFlags::AllowUnresolvedTypeVariables;
 
-  if (options.contains(TypeCheckExprFlags::ConvertTypeIsOpaqueReturnType))
-    csOptions |= ConstraintSystemFlags::UnderlyingTypeForOpaqueReturnType;
-
   if (options.contains(TypeCheckExprFlags::SubExpressionDiagnostics))
     csOptions |= ConstraintSystemFlags::SubExpressionDiagnostics;
 
@@ -2222,7 +2219,9 @@ Type TypeChecker::typeCheckExpressionImpl(Expr *&expr, DeclContext *dc,
   Expr *contextualTypeExpr = expr;
   if (auto loadExpr = dyn_cast_or_null<LoadExpr>(contextualTypeExpr))
     contextualTypeExpr = loadExpr->getSubExpr();
-  cs.setContextualType(contextualTypeExpr, convertType, convertTypePurpose);
+  cs.setContextualType(
+      contextualTypeExpr, convertType, convertTypePurpose,
+      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.
@@ -2666,8 +2665,7 @@ bool TypeChecker::typeCheckBinding(Pattern *&pattern, Expr *&initializer,
         initType = patternType;
 
         // Add a conversion constraint between the types.
-        if (!cs.Options.contains(
-                   ConstraintSystemFlags::UnderlyingTypeForOpaqueReturnType)) {
+        if (!initType->is<OpaqueTypeArchetypeType>()) {
           cs.addConstraint(ConstraintKind::Conversion, cs.getType(expr),
                            patternType, Locator, /*isFavored*/true);
         }