[Sema] Implement type erasure for dynamic replacement when the

dynamically replaceable function returns an opaque type.

Author: hborla

lib/Sema/CSGen.cpp

@@ -3903,6 +3903,38 @@ static bool generateInitPatternConstraints(
   return false;
 }
 
+static Expr *eraseTypeForDynamicReplacement(SolutionApplicationTarget target,
+                                            Expr *expr) {
+  auto purpose = target.getExprContextualTypePurpose();
+  auto *dc = target.getDeclContext();
+  auto *decl = dyn_cast_or_null<ValueDecl>(dc->getAsDecl());
+  if (!decl)
+    return expr;
+
+  if (!(purpose == CTP_ReturnStmt || purpose == CTP_ReturnSingleExpr) ||
+      !(decl->isDynamic() || decl->getDynamicallyReplacedDecl()))
+    return expr;
+
+  auto *opaque =
+      target.getExprContextualType()->getAs<OpaqueTypeArchetypeType>();
+  if (!opaque)
+    return expr;
+
+  auto protocols = opaque->getConformsTo();
+  if (protocols.size() != 1)
+    return expr;
+
+  auto *attr = protocols.front()->getAttrs().getAttribute<TypeEraserAttr>();
+  if (!attr)
+    return expr;
+
+  auto typeEraser = attr->getTypeEraserLoc().getType();
+  auto &ctx = dc->getASTContext();
+  return CallExpr::createImplicit(ctx,
+                                  TypeExpr::createImplicit(typeEraser, ctx),
+                                  {expr}, {ctx.Id_erasing});
+}
+
 bool ConstraintSystem::generateConstraints(
     SolutionApplicationTarget &target,
     FreeTypeVariableBinding allowFreeTypeVariables) {
@@ -3919,6 +3951,8 @@ bool ConstraintSystem::generateConstraints(
       target.setExprConversionType(TypeChecker::getOptionalType(expr->getLoc(), var));
     }
 
+    expr = eraseTypeForDynamicReplacement(target, expr);
+
     // Generate constraints for the main system.
     expr = generateConstraints(expr, target.getDeclContext());
     if (!expr)

test/Sema/type_eraser.swift

@@ -0,0 +1,18 @@
+// RUN: %target-swift-frontend -typecheck -disable-availability-checking -dump-ast %s | %FileCheck %s
+
+class AnyP: P {
+  init<T: P>(erasing: T) {}
+}
+
+@_typeEraser(AnyP)
+protocol P {}
+
+class ConcreteP: P {}
+
+dynamic func opaque() -> some P {
+  // CHECK: underlying_to_opaque_expr{{.*}}'some P'
+  // CHECK-NEXT: call_expr implicit type='AnyP'{{.*}}arg_labels=erasing:
+  // CHECK: call_expr type='ConcreteP'
+  ConcreteP()
+}
+