Merge pull request swiftlang#29609 from DougGregor/constraint-solver-remove-yet-more-flags

[Constraint solver] Remove yet more of TypeCheckExprFlags

Author: DougGregor

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,17 +3991,69 @@ SolutionApplicationTarget::SolutionApplicationTarget(
 
   kind = Kind::expression;
   expression.expression = expr;
+  expression.dc = dc;
   expression.contextualPurpose = contextualPurpose;
   expression.convertType = convertType;
   expression.isDiscarded = isDiscarded;
 }
 
-bool SolutionApplicationTarget::contextualTypeIsOnlyAHint(
-    bool isOpaqueReturnType) const {
+SolutionApplicationTarget SolutionApplicationTarget::forInitialization(
+    Expr *initializer, DeclContext *dc, Type patternType, Pattern *pattern) {
+  // Determine the contextual type for the initialization.
+  TypeLoc contextualType;
+  if (!isa<OptionalSomePattern>(pattern) &&
+      patternType && !patternType->isHole()) {
+    contextualType = TypeLoc::withoutLoc(patternType);
+
+    // Only provide a TypeLoc if it makes sense to allow diagnostics.
+    if (auto *typedPattern = dyn_cast<TypedPattern>(pattern)) {
+      const Pattern *inner = typedPattern->getSemanticsProvidingPattern();
+      if (isa<NamedPattern>(inner) || isa<AnyPattern>(inner)) {
+        contextualType = typedPattern->getTypeLoc();
+        if (!contextualType.getType())
+          contextualType.setType(patternType);
+      }
+    }
+  }
+
+  SolutionApplicationTarget target(
+      initializer, dc, CTP_Initialization, contextualType,
+      /*isDiscarded=*/false);
+  target.expression.pattern = pattern;
+  return target;
+}
+
+bool SolutionApplicationTarget::infersOpaqueReturnType() const {
+  assert(kind == Kind::expression);
+  switch (expression.contextualPurpose) {
+  case CTP_Initialization:
+    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 !isOpaqueReturnType;
+    return !infersOpaqueReturnType();
   case CTP_ForEachStmt:
     return true;
   case CTP_Unused:

lib/Sema/ConstraintSystem.h

@@ -1147,14 +1147,23 @@ class SolutionApplicationTarget {
 
   union {
     struct {
+      /// 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;
 
       /// The type to which the expression should be converted.
       TypeLoc convertType;
 
+      /// When initializing a pattern from the expression, this is the
+      /// pattern.
+      Pattern *pattern = nullptr;
+
       /// Whether the expression result will be discarded at the end.
       bool isDiscarded;
     } expression;
@@ -1166,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)
@@ -1185,6 +1195,10 @@ class SolutionApplicationTarget {
     function.body = body;
   }
 
+  /// Form a target for the initialization of a pattern from an expression.
+  static SolutionApplicationTarget forInitialization(
+      Expr *initializer, DeclContext *dc, Type patternType, Pattern *pattern);
+
   Expr *getAsExpr() const {
     switch (kind) {
     case Kind::expression:
@@ -1195,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;
@@ -1236,8 +1260,25 @@ class SolutionApplicationTarget {
     expression.convertType = type;
   }
 
+  /// For a pattern initialization target, retrieve the pattern.
+  Pattern *getInitializationPattern() const {
+    assert(kind == Kind::expression);
+    assert(expression.contextualPurpose == CTP_Initialization);
+    return expression.pattern;
+  }
+
+  /// Whether this is an initialization for an Optional.Some pattern.
+  bool isOptionalSomePatternInit() const {
+    return kind == Kind::expression &&
+        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);

lib/Sema/TypeCheckConstraints.cpp

@@ -2009,11 +2009,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();
@@ -2033,14 +2033,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);
 
@@ -2077,12 +2077,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
@@ -2093,7 +2092,7 @@ TypeChecker::typeCheckExpression(
 
   Type convertTo = convertType.getType();
 
-  if (options.contains(TypeCheckExprFlags::ExpressionTypeMustBeOptional)) {
+  if (target.isOptionalSomePatternInit()) {
     assert(!convertTo && "convertType and type check options conflict");
     auto *convertTypeLocator =
         cs.getConstraintLocator(expr, LocatorPathElt::ContextualType());
@@ -2108,7 +2107,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) {
@@ -2207,7 +2206,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();
@@ -2288,7 +2287,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) {
@@ -2612,54 +2611,22 @@ bool TypeChecker::typeCheckBinding(Pattern *&pattern, Expr *&initializer,
   if (!initializer)
     return true;
 
-  TypeLoc contextualType;
-  auto contextualPurpose = CTP_Unused;
-  TypeCheckExprOptions flags = None;
-
-  // Set the contextual purpose even if the pattern doesn't have a type so
-  // if there's an error we can use that information to inform diagnostics.
-  contextualPurpose = CTP_Initialization;
-
-  if (isa<OptionalSomePattern>(pattern)) {
-    flags |= TypeCheckExprFlags::ExpressionTypeMustBeOptional;
-  } else if (patternType && !patternType->isEqual(Context.TheUnresolvedType)) {
-    contextualType = TypeLoc::withoutLoc(patternType);
-
-    // If we already had an error, don't repeat the problem.
-    if (contextualType.getType()->hasError())
-      return true;
-    
-    // Allow the initializer expression to establish the underlying type of an
-    // opaque type.
-    if (auto opaqueType = patternType->getAs<OpaqueTypeArchetypeType>()){
-      flags |= TypeCheckExprFlags::ConvertTypeIsOpaqueReturnType;
-    }
-
-    // Only provide a TypeLoc if it makes sense to allow diagnostics.
-    if (auto *typedPattern = dyn_cast<TypedPattern>(pattern)) {
-      const Pattern *inner = typedPattern->getSemanticsProvidingPattern();
-      if (isa<NamedPattern>(inner) || isa<AnyPattern>(inner)) {
-        contextualType = typedPattern->getTypeLoc();
-        if (!contextualType.getType())
-          contextualType.setType(patternType);
-      }
-    }
-  }
-    
   // Type-check the initializer.
-  auto resultTy = typeCheckExpression(initializer, DC, contextualType,
-                                      contextualPurpose, flags, &listener);
+  auto target = SolutionApplicationTarget::forInitialization(
+      initializer, DC, patternType, pattern);
+  bool unresolvedTypeExprs = false;
+  auto resultTarget = typeCheckExpression(target, unresolvedTypeExprs,
+                                          None, &listener);
+
+  if (resultTarget) {
+    initializer = resultTarget->getAsExpr();
 
-  if (resultTy) {
     TypeResolutionOptions options =
         isa<EditorPlaceholderExpr>(initializer->getSemanticsProvidingExpr())
         ? TypeResolverContext::EditorPlaceholderExpr
         : TypeResolverContext::InExpression;
     options |= TypeResolutionFlags::OverrideType;
 
-    // FIXME: initTy should be the same as resultTy; now that typeCheckExpression()
-    // returns a Type and not bool, we should be able to simplify the listener
-    // implementation here.
     auto initTy = listener.getPatternInitType(nullptr);
     if (initTy->hasDependentMember())
       return true;
@@ -2673,15 +2640,17 @@ bool TypeChecker::typeCheckBinding(Pattern *&pattern, Expr *&initializer,
     } else {
       return true;
     }
+  } else {
+    initializer = target.getAsExpr();
   }
 
-  if (!resultTy && !initializer->getType())
+  if (!resultTarget && !initializer->getType())
     initializer->setType(ErrorType::get(Context));
 
   // If the type of the pattern is inferred, assign error types to the pattern
   // and its variables, to prevent it from being referenced by the constraint
   // system.
-  if (!resultTy &&
+  if (!resultTarget &&
       (patternType->hasUnresolvedType() ||
        patternType->hasUnboundGenericType())) {
     pattern->setType(ErrorType::get(Context));
@@ -2697,7 +2666,7 @@ bool TypeChecker::typeCheckBinding(Pattern *&pattern, Expr *&initializer,
     });
   }
 
-  return !resultTy;
+  return !resultTarget;
 }
 
 bool TypeChecker::typeCheckPatternBinding(PatternBindingDecl *PBD,

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");