Merge pull request #61609 from slavapestov/fix-rdar101098777

Sema: Fix opening an existential argument to a 'try self.init()' delegation

Author: slavapestov

lib/AST/Expr.cpp

@@ -1783,6 +1783,13 @@ RebindSelfInConstructorExpr::getCalledConstructor(bool &isChainToSuper) const {
       candidate = injectIntoOptionalExpr->getSubExpr();
       continue;
     }
+
+    // Look through open existential expressions
+    if (auto openExistentialExpr
+        = dyn_cast<OpenExistentialExpr>(candidate)) {
+      candidate = openExistentialExpr->getSubExpr();
+      continue;
+    }
     break;
   }
 

lib/Sema/CSApply.cpp

@@ -726,8 +726,6 @@ namespace {
         return inout->getSubExpr();
       } else if (auto force = dyn_cast<ForceValueExpr>(expr)) {
         return force->getSubExpr();
-      } else if (auto rebind = dyn_cast<RebindSelfInConstructorExpr>(expr)) {
-        return rebind->getSubExpr();
       } else {
         return nullptr;
       }
@@ -819,6 +817,11 @@ namespace {
       unsigned maxArgCount = member->getNumCurryLevels();
       unsigned depth = ExprStack.size() - getArgCount(maxArgCount);
 
+      // Invalid case -- direct call of a metatype. Has one less argument
+      // application because there's no ".init".
+      if (isa<ApplyExpr>(ExprStack.back()))
+        depth++;
+
       // Create the opaque opened value. If we started with a
       // metatype, it's a metatype.
       Type opaqueType = archetype;
@@ -3900,12 +3903,7 @@ namespace {
         expr->setSubExpr(newSubExpr);
       }
 
-      // We might have opened existentials in the argument list of the
-      // constructor call.
-      Expr *result = expr;
-      closeExistentials(result, cs.getConstraintLocator(expr));
-
-      return result;
+      return expr;
     }
 
     Expr *visitTernaryExpr(TernaryExpr *expr) {

lib/Sema/MiscDiagnostics.cpp

@@ -108,16 +108,14 @@ static void diagSyntacticUseRestrictions(const Expr *E, const DeclContext *DC,
     SmallPtrSet<DeclRefExpr*, 4> AlreadyDiagnosedBitCasts;
 
     bool IsExprStmt;
-    unsigned ExprNestingDepth;
     bool HasReachedSemanticsProvidingExpr;
 
     ASTContext &Ctx;
     const DeclContext *DC;
 
   public:
     DiagnoseWalker(const DeclContext *DC, bool isExprStmt)
-        : IsExprStmt(isExprStmt), ExprNestingDepth(0),
-          HasReachedSemanticsProvidingExpr(false),
+        : IsExprStmt(isExprStmt), HasReachedSemanticsProvidingExpr(false),
           Ctx(DC->getASTContext()), DC(DC) {}
 
     PreWalkResult<Pattern *> walkToPatternPre(Pattern *P) override {
@@ -133,11 +131,6 @@ static void diagSyntacticUseRestrictions(const Expr *E, const DeclContext *DC,
     bool shouldWalkIntoTapExpression() override { return false; }
 
     PreWalkResult<Expr *> walkToExprPre(Expr *E) override {
-      if (isa<OpenExistentialExpr>(E)) {
-        // Don't increase ExprNestingDepth.
-        return Action::Continue(E);
-      }
-
       if (auto collection = dyn_cast<CollectionExpr>(E)) {
         if (collection->isTypeDefaulted()) {
           // Diagnose type defaulted collection literals in subexpressions as
@@ -282,11 +275,9 @@ static void diagSyntacticUseRestrictions(const Expr *E, const DeclContext *DC,
       }
 
       // Diagnose 'self.init' or 'super.init' nested in another expression
-      // or closure. The ExprNestingDepth thing is to allow this to be nested
-      // inside of an OpenExistentialExpr that is at the top level.
+      // or closure.
       if (auto *rebindSelfExpr = dyn_cast<RebindSelfInConstructorExpr>(E)) {
-        if (ExprNestingDepth > 0 || !IsExprStmt ||
-            DC->getParent()->isLocalContext()) {
+        if (!Parent.isNull() || !IsExprStmt || DC->getParent()->isLocalContext()) {
           bool isChainToSuper;
           (void)rebindSelfExpr->getCalledConstructor(isChainToSuper);
           Ctx.Diags.diagnose(E->getLoc(), diag::init_delegation_nested,
@@ -357,17 +348,10 @@ static void diagSyntacticUseRestrictions(const Expr *E, const DeclContext *DC,
         HasReachedSemanticsProvidingExpr = true;
       }
 
-      ++ExprNestingDepth;
-
       return Action::Continue(E);
     }
 
     PostWalkResult<Expr *> walkToExprPost(Expr *E) override {
-      if (isa<OpenExistentialExpr>(E))
-        return Action::Continue(E);
-
-      assert(ExprNestingDepth != 0);
-      --ExprNestingDepth;
       return Action::Continue(E);
     }
 
@@ -1525,7 +1509,6 @@ static void diagRecursivePropertyAccess(const Expr *E, const DeclContext *DC) {
   };
 
   DiagnoseWalker walker(var, fn);
-
   const_cast<Expr *>(E)->walk(walker);
 }
 

test/SILGen/opened_existential_in_init_delegation.swift

@@ -1,4 +1,4 @@
-// RUN: %target-swift-emit-silgen %s | %FileCheck %s
+// RUN: %target-swift-emit-silgen %s -disable-availability-checking
 
 protocol P {}
 class C {
@@ -7,10 +7,28 @@ class C {
   convenience init(y: any P) { self.init(x: y) }
 }
 
-// CHECK-LABEL: sil hidden [ossa] @$s37opened_existential_in_init_delegation1CC1yAcA1P_p_tcfC : $@convention(method) (@in any P, @thick C.Type) -> @owned C {
-// CHECK: [[OPENED:%.*]] = open_existential_addr immutable_access %0 : $*any P to $*@opened("{{.*}}", any P) Self
-// CHECK: [[COPIED:%.*]] = alloc_stack $@opened("{{.*}}", any P) Self
-// CHECK: copy_addr [[OPENED]] to [initialization] [[COPIED]] : $*@opened("{{.*}}", any P) Self
-// CHECK: [[FN:%.*]] = class_method %1 : $@thick C.Type, #C.init!allocator :  (C.Type) -> (some P) -> C, $@convention(method) <τ_0_0 where τ_0_0 : P> (@in τ_0_0, @thick C.Type) -> @owned C
-// CHECK: apply [[FN]]<@opened("{{.*}}", any P) Self>([[COPIED]], %1) : $@convention(method) <τ_0_0 where τ_0_0 : P> (@in τ_0_0, @thick C.Type) -> @owned C
-// CHECK: dealloc_stack [[COPIED]] : $*@opened("{{.*}}", any P) Self
+enum E {
+  init(p: some P, throwing: ()) throws {}
+  init(p: some P, async: ()) async {}
+  init?(p: some P, failable: ()) {}
+
+  init(p: any P, withTry: ()) throws {
+    try self.init(p: p, throwing: ())
+  }
+
+  init(p: any P, withForceTry: ()) {
+    try! self.init(p: p, throwing: ())
+  }
+
+  init(p: any P, withAwait: ()) async {
+    await self.init(p: p, async: ())
+  }
+
+  init?(p: any P, withFailable: ()) {
+    self.init(p: p, failable: ())
+  }
+
+  init(p: any P, withForce: ()) {
+    self.init(p: p, failable: ())!
+  }
+}