Merge pull request swiftlang#78171 from xedin/rdar-140300022

[TypeChecker/SILGen] Allow `any Sendable` to match `Any` while matching generic arguments

Author: xedin

include/swift/AST/DiagnosticsSema.def

@@ -2798,6 +2798,9 @@ ERROR(types_not_inherited_decl,none,
 ERROR(types_not_inherited_in_decl_ref,none,
       "referencing %kind0 on %1 requires that %2 inherit from %3",
       (const ValueDecl *, Type, Type, Type))
+ERROR(cannot_reference_conditional_member_on_base_multiple_mismatches,none,
+      "cannot reference %kind0 on %1",
+      (const ValueDecl *, Type))
 NOTE(where_requirement_failure_one_subst,none,
      "where %0 = %1", (Type, Type))
 NOTE(where_requirement_failure_both_subst,none,

include/swift/AST/Expr.h

@@ -3600,6 +3600,24 @@ class ActorIsolationErasureExpr : public ImplicitConversionExpr {
   }
 };
 
+/// UnsafeCastExpr - A special kind of conversion that performs an unsafe
+/// bitcast from one type to the other.
+///
+/// Note that this is an unsafe operation and type-checker is allowed to
+/// use this only in a limited number of cases like: `any Sendable` -> `Any`
+/// conversions in some positions, covariant conversions of function and
+/// function result types.
+class UnsafeCastExpr : public ImplicitConversionExpr {
+public:
+  UnsafeCastExpr(Expr *subExpr, Type type)
+      : ImplicitConversionExpr(ExprKind::UnsafeCast, subExpr, type) {
+  }
+
+  static bool classof(const Expr *E) {
+    return E->getKind() == ExprKind::UnsafeCast;
+  }
+};
+
 /// Extracts the isolation of a dynamically isolated function value.
 class ExtractFunctionIsolationExpr : public Expr {
   /// The function value expression from which to extract the

include/swift/AST/ExprNodes.def

@@ -191,7 +191,8 @@ ABSTRACT_EXPR(ImplicitConversion, Expr)
   EXPR(LinearFunctionExtractOriginal, ImplicitConversionExpr)
   EXPR(LinearToDifferentiableFunction, ImplicitConversionExpr)
   EXPR(ActorIsolationErasure, ImplicitConversionExpr)
-  EXPR_RANGE(ImplicitConversion, Load, ActorIsolationErasure)
+  EXPR(UnsafeCast, ImplicitConversionExpr)
+  EXPR_RANGE(ImplicitConversion, Load, UnsafeCast)
 ABSTRACT_EXPR(ExplicitCast, Expr)
   ABSTRACT_EXPR(CheckedCast, ExplicitCastExpr)
     EXPR(ForcedCheckedCast, CheckedCastExpr)

include/swift/AST/Types.h

@@ -675,6 +675,9 @@ class alignas(1 << TypeAlignInBits) TypeBase
   /// Is this an existential containing only marker protocols?
   bool isMarkerExistential();
 
+  /// Is this `any Sendable` type?
+  bool isSendableExistential();
+
   bool isPlaceholder();
 
   /// Returns true if this contextual type does not satisfy a conformance to

lib/AST/ASTDumper.cpp

@@ -2834,6 +2834,12 @@ class PrintExpr : public ExprVisitor<PrintExpr, void, StringRef>,
     printFoot();
   }
 
+  void visitUnsafeCastExpr(UnsafeCastExpr *E, StringRef label) {
+    printCommon(E, "unsafe_cast_expr", label);
+    printRec(E->getSubExpr());
+    printFoot();
+  }
+
   void visitExtractFunctionIsolationExpr(ExtractFunctionIsolationExpr *E,
                                          StringRef label) {
     printCommon(E, "extract_function_isolation", label);

lib/AST/ASTPrinter.cpp

@@ -5343,6 +5343,9 @@ void PrintAST::visitLinearToDifferentiableFunctionExpr(swift::LinearToDifferenti
 void PrintAST::visitActorIsolationErasureExpr(ActorIsolationErasureExpr *expr) {
 }
 
+void PrintAST::visitUnsafeCastExpr(UnsafeCastExpr *expr) {
+}
+
 void PrintAST::visitExtractFunctionIsolationExpr(ExtractFunctionIsolationExpr *expr) {
   visit(expr->getFunctionExpr());
   Printer << ".isolation";

lib/AST/Expr.cpp

@@ -444,6 +444,7 @@ ConcreteDeclRef Expr::getReferencedDecl(bool stopAtParenExpr) const {
   PASS_THROUGH_REFERENCE(UnderlyingToOpaque, getSubExpr);
   PASS_THROUGH_REFERENCE(Unreachable, getSubExpr);
   PASS_THROUGH_REFERENCE(ActorIsolationErasure, getSubExpr);
+  PASS_THROUGH_REFERENCE(UnsafeCast, getSubExpr);
   NO_REFERENCE(Coerce);
   NO_REFERENCE(ForcedCheckedCast);
   NO_REFERENCE(ConditionalCheckedCast);
@@ -813,6 +814,7 @@ bool Expr::canAppendPostfixExpression(bool appendingPostfixOperator) const {
   case ExprKind::UnderlyingToOpaque:
   case ExprKind::Unreachable:
   case ExprKind::ActorIsolationErasure:
+  case ExprKind::UnsafeCast:
   case ExprKind::TypeValue:
     // Implicit conversion nodes have no syntax of their own; defer to the
     // subexpression.
@@ -1043,6 +1045,7 @@ bool Expr::isValidParentOfTypeExpr(Expr *typeExpr) const {
   case ExprKind::CurrentContextIsolation:
   case ExprKind::ActorIsolationErasure:
   case ExprKind::ExtractFunctionIsolation:
+  case ExprKind::UnsafeCast:
     return false;
   }
 

lib/AST/Type.cpp

@@ -163,6 +163,17 @@ bool TypeBase::isMarkerExistential() {
   return true;
 }
 
+bool TypeBase::isSendableExistential() {
+  Type constraint = this;
+  if (auto existential = constraint->getAs<ExistentialType>())
+    constraint = existential->getConstraintType();
+
+  if (!constraint->isConstraintType())
+    return false;
+
+  return constraint->getKnownProtocol() == KnownProtocolKind::Sendable;
+}
+
 bool TypeBase::isPlaceholder() {
   return is<PlaceholderType>();
 }

lib/SILGen/SILGenBuilder.cpp

@@ -757,6 +757,31 @@ ManagedValue SILGenBuilder::createUncheckedBitCast(SILLocation loc,
   return cloner.clone(cast);
 }
 
+ManagedValue SILGenBuilder::createUncheckedForwardingCast(SILLocation loc,
+                                                          ManagedValue value,
+                                                          SILType type) {
+  CleanupCloner cloner(*this, value);
+  SILValue cast = createUncheckedForwardingCast(loc, value.getValue(), type);
+  
+  // Currently createUncheckedBitCast only produces these
+  // instructions. We assert here to make sure if this changes, this code is
+  // updated.
+  assert((isa<UncheckedTrivialBitCastInst>(cast) ||
+          isa<UncheckedRefCastInst>(cast) ||
+          isa<UncheckedValueCastInst>(cast) ||
+          isa<ConvertFunctionInst>(cast)) &&
+         "SILGenBuilder is out of sync with SILBuilder.");
+
+  // If we have a trivial inst, just return early.
+  if (isa<UncheckedTrivialBitCastInst>(cast))
+    return ManagedValue::forObjectRValueWithoutOwnership(cast);
+
+  // Otherwise, we forward the cleanup of the input value and place the cleanup
+  // on the cast value since unchecked_ref_cast is "forwarding".
+  value.forward(SGF);
+  return cloner.clone(cast);
+}
+
 ManagedValue SILGenBuilder::createOpenExistentialRef(SILLocation loc,
                                                      ManagedValue original,
                                                      SILType type) {

lib/SILGen/SILGenBuilder.h

@@ -340,6 +340,11 @@ class SILGenBuilder : public SILBuilder {
   ManagedValue createUncheckedBitCast(SILLocation loc, ManagedValue original,
                                       SILType type);
 
+  using SILBuilder::createUncheckedForwardingCast;
+  ManagedValue createUncheckedForwardingCast(SILLocation loc,
+                                             ManagedValue original,
+                                             SILType type);
+
   using SILBuilder::createOpenExistentialRef;
   ManagedValue createOpenExistentialRef(SILLocation loc, ManagedValue arg,
                                         SILType openedType);