[Constraint system] Eliminate TypeCheckExprFlags::ConvertTypeIsOpaqueReturnType

DougGregor · DougGregor · commit 9278fb8c22b0 · 2020-02-02T23:41:24.000-08:00
We can compute this information based solely on the SolutionApplicationTarget,
so do it.
diff --git a/lib/Sema/ConstraintSystem.cpp b/lib/Sema/ConstraintSystem.cpp
@@ -3970,7 +3970,7 @@ ValueDecl *ConstraintSystem::findResolvedMemberRef(ConstraintLocator *locator) {
 }
 
 SolutionApplicationTarget::SolutionApplicationTarget(
-    Expr *expr, ContextualTypePurpose contextualPurpose,
+    Expr *expr, DeclContext *dc, 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
@@ -3991,13 +3991,14 @@ SolutionApplicationTarget::SolutionApplicationTarget(
 
   kind = Kind::expression;
   expression.expression = expr;
+  expression.dc = dc;
   expression.contextualPurpose = contextualPurpose;
   expression.convertType = convertType;
   expression.isDiscarded = isDiscarded;
 }
 
 SolutionApplicationTarget SolutionApplicationTarget::forInitialization(
-    Expr *initializer, Type patternType, Pattern *pattern) {
+    Expr *initializer, DeclContext *dc, Type patternType, Pattern *pattern) {
   // Determine the contextual type for the initialization.
   TypeLoc contextualType;
   if (!isa<OptionalSomePattern>(pattern) &&
@@ -4016,18 +4017,43 @@ SolutionApplicationTarget SolutionApplicationTarget::forInitialization(
   }
 
   SolutionApplicationTarget target(
-      initializer, CTP_Initialization, contextualType,
+      initializer, dc, CTP_Initialization, contextualType,
       /*isDiscarded=*/false);
   target.expression.pattern = pattern;
   return target;
 }
 
-bool SolutionApplicationTarget::contextualTypeIsOnlyAHint(
-    bool isOpaqueReturnType) const {
+bool SolutionApplicationTarget::infersOpaqueReturnType() const {
   assert(kind == Kind::expression);
   switch (expression.contextualPurpose) {
   case CTP_Initialization:
-    return !isOpaqueReturnType;
+    if (Type convertType = expression.convertType.getType()) {
+      return convertType->is<OpaqueTypeArchetypeType>();
+    }
+    return false;
+
+  case CTP_ReturnStmt:
+  case CTP_ReturnSingleExpr:
+    if (Type convertType = expression.convertType.getType()) {
+      if (auto opaqueType = convertType->getAs<OpaqueTypeArchetypeType>()) {
+        auto dc = getDeclContext();
+        if (auto func = dyn_cast<AbstractFunctionDecl>(dc)) {
+          return opaqueType->getDecl()->isOpaqueReturnTypeOfFunction(func);
+        }
+      }
+    }
+    return false;
+
+  default:
+    return false;
+  }
+}
+
+bool SolutionApplicationTarget::contextualTypeIsOnlyAHint() const {
+  assert(kind == Kind::expression);
+  switch (expression.contextualPurpose) {
+  case CTP_Initialization:
+    return !infersOpaqueReturnType();
   case CTP_ForEachStmt:
     return true;
   case CTP_Unused:
diff --git a/lib/Sema/ConstraintSystem.h b/lib/Sema/ConstraintSystem.h
@@ -1150,6 +1150,10 @@ class SolutionApplicationTarget {
       /// The expression being type-checked.
       Expr *expression;
 
+      /// The declaration context in which the expression is being
+      /// type-checked.
+      DeclContext *dc;
+
       /// The purpose of the contextual type.
       ContextualTypePurpose contextualPurpose;
 
@@ -1171,14 +1175,15 @@ class SolutionApplicationTarget {
   };
 
 public:
-  SolutionApplicationTarget(Expr *expr,
+  SolutionApplicationTarget(Expr *expr, DeclContext *dc,
                             ContextualTypePurpose contextualPurpose,
                             Type convertType, bool isDiscarded)
-      : SolutionApplicationTarget(expr, contextualPurpose,
+      : SolutionApplicationTarget(expr, dc, contextualPurpose,
                                   TypeLoc::withoutLoc(convertType),
                                   isDiscarded) { }
 
-  SolutionApplicationTarget(Expr *expr, ContextualTypePurpose contextualPurpose,
+  SolutionApplicationTarget(Expr *expr, DeclContext *dc,
+                            ContextualTypePurpose contextualPurpose,
                             TypeLoc convertType, bool isDiscarded);
 
   SolutionApplicationTarget(AnyFunctionRef fn)
@@ -1192,7 +1197,7 @@ class SolutionApplicationTarget {
 
   /// Form a target for the initialization of a pattern from an expression.
   static SolutionApplicationTarget forInitialization(
-      Expr *initializer, Type patternType, Pattern *pattern);
+      Expr *initializer, DeclContext *dc, Type patternType, Pattern *pattern);
 
   Expr *getAsExpr() const {
     switch (kind) {
@@ -1204,6 +1209,16 @@ class SolutionApplicationTarget {
     }
   }
 
+  DeclContext *getDeclContext() const {
+    switch (kind) {
+    case Kind::expression:
+      return expression.dc;
+
+    case Kind::function:
+      return function.function.getAsDeclContext();
+    }
+  }
+
   ContextualTypePurpose getExprContextualTypePurpose() const {
     assert(kind == Kind::expression);
     return expression.contextualPurpose;
@@ -1258,9 +1273,12 @@ class SolutionApplicationTarget {
         expression.contextualPurpose == CTP_Initialization &&
         isa<OptionalSomePattern>(expression.pattern);
   }
-  
+
+  /// Whether this context infers an opaque return type.
+  bool infersOpaqueReturnType() const;
+
   /// Whether the contextual type is only a hint, rather than a type
-  bool contextualTypeIsOnlyAHint(bool isOpaqueReturnType) const;
+  bool contextualTypeIsOnlyAHint() const;
 
   bool isDiscardedExpr() const {
     assert(kind == Kind::expression);
diff --git a/lib/Sema/TypeCheckConstraints.cpp b/lib/Sema/TypeCheckConstraints.cpp
@@ -2066,11 +2066,11 @@ Type TypeChecker::typeCheckExpression(Expr *&expr, DeclContext *dc,
                                       ExprTypeCheckListener *listener,
                                       ConstraintSystem *baseCS) {
   SolutionApplicationTarget target(
-      expr, convertTypePurpose, convertType,
+      expr, dc, convertTypePurpose, convertType,
       options.contains(TypeCheckExprFlags::IsDiscarded));
   bool unresolvedTypeExprs = false;
   auto resultTarget = typeCheckExpression(
-      target, dc, unresolvedTypeExprs, options, listener, baseCS);
+      target, unresolvedTypeExprs, options, listener, baseCS);
   if (!resultTarget) {
     expr = target.getAsExpr();
     return Type();
@@ -2090,14 +2090,14 @@ Type TypeChecker::typeCheckExpression(Expr *&expr, DeclContext *dc,
 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();
+  DeclContext *dc = target.getDeclContext();
+  auto &Context = dc->getASTContext();
   FrontendStatsTracer StatsTracer(Context.Stats, "typecheck-expr", expr);
   PrettyStackTraceExpr stackTrace(Context, "type-checking", expr);
 
@@ -2134,12 +2134,11 @@ TypeChecker::typeCheckExpression(
   cs.setContextualType(
       contextualTypeExpr, convertType,
       target.getExprContextualTypePurpose(),
-      options.contains(TypeCheckExprFlags::ConvertTypeIsOpaqueReturnType));
+      target.infersOpaqueReturnType());
 
   // 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 (target.contextualTypeIsOnlyAHint(
-          options.contains(TypeCheckExprFlags::ConvertTypeIsOpaqueReturnType)))
+  if (target.contextualTypeIsOnlyAHint())
     convertType = TypeLoc();
 
   // If the client can handle unresolved type variables, leave them in the
@@ -2165,7 +2164,7 @@ TypeChecker::typeCheckExpression(
 
   // Attempt to solve the constraint system.
   SolutionApplicationTarget innerTarget(
-      expr, target.getExprContextualTypePurpose(), convertTo,
+      expr, dc, target.getExprContextualTypePurpose(), convertTo,
       target.isDiscardedExpr());
   auto viable = cs.solve(innerTarget, listener, allowFreeTypeVariables);
   if (!viable) {
@@ -2264,7 +2263,7 @@ getTypeOfExpressionWithoutApplying(Expr *&expr, DeclContext *dc,
   if (needClearType)
     expr->setType(Type());
   SolutionApplicationTarget target(
-      expr, CTP_Unused, Type(), /*isDiscarded=*/false);
+      expr, dc, CTP_Unused, Type(), /*isDiscarded=*/false);
   auto viable = cs.solve(target, listener, allowFreeTypeVariables);
   if (!viable) {
     recoverOriginalType();
@@ -2345,7 +2344,7 @@ void TypeChecker::getPossibleTypesOfExpressionWithoutApplying(
     expr->setType(Type());
 
   SolutionApplicationTarget target(
-      expr, CTP_Unused, Type(), /*isDiscarded=*/false);
+      expr, dc, CTP_Unused, Type(), /*isDiscarded=*/false);
   if (auto viable = cs.solve(target, listener, allowFreeTypeVariables)) {
     expr = target.getAsExpr();
     for (auto &solution : *viable) {
@@ -2671,9 +2670,9 @@ bool TypeChecker::typeCheckBinding(Pattern *&pattern, Expr *&initializer,
 
   // Type-check the initializer.
   auto target = SolutionApplicationTarget::forInitialization(
-      initializer, patternType, pattern);
+      initializer, DC, patternType, pattern);
   bool unresolvedTypeExprs = false;
-  auto resultTarget = typeCheckExpression(target, DC, unresolvedTypeExprs,
+  auto resultTarget = typeCheckExpression(target, unresolvedTypeExprs,
                                           None, &listener);
 
   if (resultTarget) {
diff --git a/lib/Sema/TypeCheckStmt.cpp b/lib/Sema/TypeCheckStmt.cpp
@@ -517,23 +517,6 @@ class StmtChecker : public StmtVisitor<StmtChecker, Stmt*> {
     
     TypeCheckExprOptions options = {};
     
-    // If the result type is an opaque type, this is an opportunity to resolve
-    // the underlying type.
-    auto isOpaqueReturnTypeOfCurrentFunc = [&](OpaqueTypeDecl *opaque) -> bool {
-      // Closures currently don't support having opaque types.
-      auto funcDecl = TheFunc->getAbstractFunctionDecl();
-      if (!funcDecl)
-        return false;
-
-      return opaque->isOpaqueReturnTypeOfFunction(funcDecl);
-    };
-    
-    if (auto opaque = ResultTy->getAs<OpaqueTypeArchetypeType>()) {
-      if (isOpaqueReturnTypeOfCurrentFunc(opaque->getDecl())) {
-        options |= TypeCheckExprFlags::ConvertTypeIsOpaqueReturnType;
-      }
-    }
-
     if (EndTypeCheckLoc.isValid()) {
       assert(DiagnosticSuppression::isEnabled(getASTContext().Diags) &&
              "Diagnosing and AllowUnresolvedTypeVariables don't seem to mix");
diff --git a/lib/Sema/TypeChecker.h b/lib/Sema/TypeChecker.h
@@ -183,13 +183,6 @@ enum class TypeCheckExprFlags {
   /// as part of the expression diagnostics, which is attempting to narrow
   /// down failure location.
   SubExpressionDiagnostics = 0x400,
-  
-  /// If set, the 'convertType' specified to typeCheckExpression is the opaque
-  /// return type of the declaration being checked. The archetype should be
-  /// opened into a type variable to provide context to the expression, and
-  /// the resulting type will be a candidate for binding the underlying
-  /// type.
-  ConvertTypeIsOpaqueReturnType = 0x800,
 };
 
 using TypeCheckExprOptions = OptionSet<TypeCheckExprFlags>;
@@ -831,7 +824,6 @@ class TypeChecker final {
 
   static Optional<constraints::SolutionApplicationTarget>
   typeCheckExpression(constraints::SolutionApplicationTarget &target,
-                      DeclContext *dc,
                       bool &unresolvedTypeExprs,
                       TypeCheckExprOptions options = TypeCheckExprOptions(),
                       ExprTypeCheckListener *listener = nullptr,
