Merge pull request #79406 from hborla/type-eraser-availability

[ConstraintSystem] Always choose an available type eraser type.

Author: hborla

include/swift/AST/DeclAttr.def

@@ -267,7 +267,7 @@ SIMPLE_DECL_ATTR(_inheritsConvenienceInitializers, InheritsConvenienceInitialize
   OnClass | UserInaccessible | NotSerialized | APIStableToAdd | ABIStableToAdd | APIBreakingToRemove | ABIBreakingToRemove,
   93)
 DECL_ATTR(_typeEraser, TypeEraser,
-  OnProtocol | UserInaccessible | ABIStableToAdd | ABIBreakingToRemove | APIStableToAdd | APIBreakingToRemove,
+  OnProtocol | UserInaccessible | ABIStableToAdd | ABIBreakingToRemove | APIStableToAdd | APIBreakingToRemove | AllowMultipleAttributes,
   94)
 SIMPLE_DECL_ATTR(IBSegueAction, IBSegueAction,
   OnFunc | ABIStableToAdd | ABIStableToRemove | APIStableToAdd | APIStableToRemove,

lib/Sema/ConstraintSystem.cpp

@@ -4553,6 +4553,8 @@ Expr *ConstraintSystem::buildAutoClosureExpr(Expr *expr,
 Expr *ConstraintSystem::buildTypeErasedExpr(Expr *expr, DeclContext *dc,
                                             Type contextualType,
                                             ContextualTypePurpose purpose) {
+  auto &ctx = dc->getASTContext();
+
   if (purpose != CTP_ReturnStmt)
     return expr;
 
@@ -4571,13 +4573,33 @@ Expr *ConstraintSystem::buildTypeErasedExpr(Expr *expr, DeclContext *dc,
     return expr;
 
   auto *PD = protocols.front();
-  auto *attr = PD->getAttrs().getAttribute<TypeEraserAttr>();
-  if (!attr)
+
+  auto contextAvailability =
+      TypeChecker::availabilityAtLocation(expr->getLoc(), dc);
+  auto refinedAvailability =
+      AvailabilityContext::forPlatformRange(
+        AvailabilityRange::alwaysAvailable(), ctx);
+
+  // The least available type eraser for the enclosing context.
+  Type typeEraser;
+  for (auto *attr : PD->getAttrs().getAttributes<TypeEraserAttr>()) {
+    auto eraser = attr->getResolvedType(PD);
+    assert(eraser && "Failed to resolve eraser type!");
+
+    auto *nominal = eraser->getAnyNominal();
+    auto nominalAvailability =
+        TypeChecker::availabilityForDeclSignature(nominal);
+
+    if (contextAvailability.isContainedIn(nominalAvailability) &&
+        nominalAvailability.isContainedIn(refinedAvailability)) {
+      refinedAvailability = nominalAvailability;
+      typeEraser = eraser;
+    }
+  }
+
+  if (!typeEraser)
     return expr;
 
-  auto typeEraser = attr->getResolvedType(PD);
-  assert(typeEraser && "Failed to resolve eraser type!");
-  auto &ctx = dc->getASTContext();
   auto *argList = ArgumentList::forImplicitSingle(ctx, ctx.Id_erasing, expr);
   return CallExpr::createImplicit(
       ctx, TypeExpr::createImplicit(typeEraser, ctx), argList);

test/Sema/type_eraser.swift

@@ -1,10 +1,13 @@
-// RUN: %target-swift-frontend -typecheck -disable-availability-checking -dump-ast %s | %FileCheck %s
+// RUN: %target-swift-frontend -target %target-cpu-apple-macosx10.15 -typecheck -dump-ast %s | %FileCheck %s
+
+// REQUIRES: OS=macosx
 
 class AnyP: P {
   init<T: P>(erasing: T) {}
 }
 
 @_typeEraser(AnyP)
+@_typeEraser(NewAnyP)
 protocol P {}
 
 struct ConcreteP: P, Hashable {}
@@ -119,3 +122,61 @@ extension DynamicReplacement {
     return ConcreteP()
   }
 }
+
+@available(macOS 100, *)
+struct NewAnyP: P {
+  init(erasing: some P) {}
+}
+
+@available(macOS 100, *)
+struct NewConcreteP: P {}
+
+// CHECK-LABEL: var_decl{{.*}}x0
+dynamic var x0: some P {
+  // CHECK:      return_stmt
+  // CHECK-NEXT:   underlying_to_opaque_expr implicit type="some P"
+  // CHECK-NEXT:     call_expr implicit type="AnyP"
+  ConcreteP()
+}
+
+// CHECK-LABEL: var_decl{{.*}}x1
+@available(macOS 99, *)
+dynamic var x1: some P {
+  // CHECK:      return_stmt
+  // CHECK-NEXT:   underlying_to_opaque_expr implicit type="some P"
+  // CHECK-NEXT:     call_expr implicit type="AnyP"
+  ConcreteP()
+}
+
+// CHECK-LABEL: var_decl{{.*}}x2
+@available(macOS 100, *)
+dynamic var x2: some P {
+  // CHECK:      return_stmt
+  // CHECK-NEXT:   underlying_to_opaque_expr implicit type="some P"
+  // CHECK-NEXT:     call_expr implicit type="NewAnyP"
+  ConcreteP()
+}
+
+// CHECK-LABEL: var_decl{{.*}}x3
+@available(macOS 101, *)
+dynamic var x3: some P {
+  // CHECK:      return_stmt
+  // CHECK-NEXT:   underlying_to_opaque_expr implicit type="some P"
+  // CHECK-NEXT:     call_expr implicit type="NewAnyP"
+  ConcreteP()
+}
+
+// CHECK-LABEL: var_decl{{.*}}x4
+dynamic var x4: some P {
+  if #available(macOS 101, *) {
+    // CHECK:      return_stmt
+    // CHECK-NEXT:   underlying_to_opaque_expr implicit type="some P"
+    // CHECK-NEXT:     call_expr implicit type="NewAnyP"
+    return NewConcreteP()
+  } else {
+    // CHECK:      return_stmt
+    // CHECK-NEXT:   underlying_to_opaque_expr implicit type="some P"
+    // CHECK-NEXT:     call_expr implicit type="AnyP"
+    return ConcreteP()
+  }
+}