SILGen: Avoid passing an expression to emitDynamicSubscriptExpr

Author: AnthonyLatsis

lib/SILGen/SILGenApply.cpp

@@ -6255,17 +6255,14 @@ RValue SILGenFunction::emitDynamicMemberRef(SILLocation loc, SILValue operand,
                 emitManagedRValueWithCleanup(optResult, optTL));
 }
 
-RValue SILGenFunction::emitDynamicSubscriptExpr(DynamicSubscriptExpr *e,
+RValue
+SILGenFunction::emitDynamicSubscriptGetterApply(SILLocation loc,
+                                                SILValue operand,
+                                                ConcreteDeclRef subscriptRef,
+                                                PreparedArguments &&indexArgs,
+                                                CanType resultTy,
                                                 SGFContext c) {
-  // Emit the base operand.
-  ManagedValue managedBase = emitRValueAsSingleValue(e->getBase());
-
-  SILValue base = managedBase.getValue();
-
-  // Emit the index.
-  auto *indexExpr = e->getArgs()->getUnaryExpr();
-  assert(indexExpr);
-  RValue index = emitRValue(indexExpr);
+  assert(resultTy->isOptional());
 
   // Create the continuation block.
   SILBasicBlock *contBB = createBasicBlock();
@@ -6276,72 +6273,77 @@ RValue SILGenFunction::emitDynamicSubscriptExpr(DynamicSubscriptExpr *e,
   // Create the has-member block.
   SILBasicBlock *hasMemberBB = createBasicBlock();
 
-  const TypeLowering &optTL = getTypeLowering(e->getType());
-  auto loweredOptTy = optTL.getLoweredType();
-  SILValue optTemp = emitTemporaryAllocation(e, loweredOptTy);
+  const TypeLowering &optTL = getTypeLowering(resultTy);
+  const SILValue optTemp = emitTemporaryAllocation(loc, optTL.getLoweredType());
 
   // Create the branch.
-  auto subscriptDecl = cast<SubscriptDecl>(e->getMember().getDecl());
+  auto *subscriptDecl = cast<SubscriptDecl>(subscriptRef.getDecl());
   auto member = SILDeclRef(subscriptDecl->getOpaqueAccessor(AccessorKind::Get),
                            SILDeclRef::Kind::Func)
     .asForeign();
-  B.createDynamicMethodBranch(e, base, member, hasMemberBB, noMemberBB);
+  B.createDynamicMethodBranch(loc, operand, member, hasMemberBB, noMemberBB);
 
   // Create the has-member branch.
   {
     B.emitBlock(hasMemberBB);
 
-    FullExpr hasMemberScope(Cleanups, CleanupLocation(e));
+    FullExpr hasMemberScope(Cleanups, CleanupLocation(loc));
 
     // The argument to the has-member block is the uncurried method.
     // Build the substituted getter type from the AST nodes.
-    auto valueTy = e->getType()->getCanonicalType().getOptionalObjectType();
+    const CanType valueTy = resultTy.getOptionalObjectType();
 
-    // Objective-C subscripts only ever have a single parameter.
-    //
     // FIXME: Verify ExtInfo state is correct, not working by accident.
     CanFunctionType::ExtInfo methodInfo;
-    FunctionType::Param indexArg(indexExpr->getType()->getCanonicalType());
-    auto methodTy = CanFunctionType::get({indexArg}, valueTy, methodInfo);
+    const auto methodTy =
+        CanFunctionType::get(indexArgs.getParams(), valueTy, methodInfo);
     auto foreignMethodTy =
-      getPartialApplyOfDynamicMethodFormalType(SGM, member, e->getMember());
+        getPartialApplyOfDynamicMethodFormalType(SGM, member, subscriptRef);
 
     // FIXME: Verify ExtInfo state is correct, not working by accident.
     CanFunctionType::ExtInfo functionInfo;
-    FunctionType::Param baseArg(base->getType().getASTType());
+    FunctionType::Param baseArg(operand->getType().getASTType());
     auto functionTy = CanFunctionType::get({baseArg}, methodTy, functionInfo);
     auto loweredMethodTy = getDynamicMethodLoweredType(SGM.M, member,
                                                        functionTy);
     SILValue memberArg =
         hasMemberBB->createPhiArgument(loweredMethodTy, OwnershipKind::Owned);
     // Emit the application of 'self'.
-    Scope applyScope(Cleanups, CleanupLocation(e));
-    ManagedValue result = emitDynamicPartialApply(*this, e, memberArg, base,
-                                                  foreignMethodTy, methodTy);
-    // Emit the index.
-    llvm::SmallVector<ManagedValue, 2> indexArgs;
-    std::move(index).getAll(indexArgs);
-    
-    auto resultRV = emitMonomorphicApply(e, result, indexArgs,
+    Scope applyScope(Cleanups, CleanupLocation(loc));
+    ManagedValue result = emitDynamicPartialApply(
+        *this, loc, memberArg, operand, foreignMethodTy, methodTy);
+
+    // Collect the index values for application.
+    llvm::SmallVector<ManagedValue, 2> indexValues;
+    for (auto &source : std::move(indexArgs).getSources()) {
+      // @objc subscripts cannot have 'inout' indices.
+      RValue rVal = std::move(source).asKnownRValue(*this);
+
+      // @objc subscripts cannot have tuple indices.
+      indexValues.push_back(std::move(rVal).getScalarValue());
+    }
+
+    auto resultRV = emitMonomorphicApply(loc, result, indexValues,
                                          foreignMethodTy.getResult(), valueTy,
                                          ApplyOptions(), None, None);
 
     // Package up the result in an optional.
-    emitInjectOptionalValueInto(e, {e, std::move(resultRV)}, optTemp, optTL);
+    emitInjectOptionalValueInto(loc, {loc, std::move(resultRV)}, optTemp,
+                                optTL);
 
     applyScope.pop();
     // Branch to the continuation block.
-    B.createBranch(e, contBB);
+    B.createBranch(loc, contBB);
   }
 
   // Create the no-member branch.
   {
     B.emitBlock(noMemberBB);
 
-    emitInjectOptionalNothingInto(e, optTemp, optTL);
+    emitInjectOptionalNothingInto(loc, optTemp, optTL);
 
     // Branch to the continuation block.
-    B.createBranch(e, contBB);
+    B.createBranch(loc, contBB);
   }
 
   // Emit the continuation block.
@@ -6350,8 +6352,9 @@ RValue SILGenFunction::emitDynamicSubscriptExpr(DynamicSubscriptExpr *e,
   // Package up the result.
   auto optResult = optTemp;
   if (optTL.isLoadable())
-    optResult = optTL.emitLoad(B, e, optResult, LoadOwnershipQualifier::Take);
-  return RValue(*this, e, emitManagedRValueWithCleanup(optResult, optTL));
+    optResult = optTL.emitLoad(B, loc, optResult, LoadOwnershipQualifier::Take);
+  return RValue(*this, loc, resultTy,
+                emitManagedRValueWithCleanup(optResult, optTL));
 }
 
 SmallVector<ManagedValue, 4> SILGenFunction::emitKeyPathSubscriptOperands(

lib/SILGen/SILGenExpr.cpp

@@ -2248,7 +2248,24 @@ RValue RValueEmitter::visitDynamicSubscriptExpr(
                                       DynamicSubscriptExpr *E, SGFContext C) {
   assert(!E->isImplicitlyAsync() && "an actor-isolated @objc member?");
   assert(!E->isImplicitlyThrows() && "an distributed-actor-isolated @objc member?");
-  return SGF.emitDynamicSubscriptExpr(E, C);
+
+  // Emit the base operand.
+  SILValue Operand = SGF.emitRValueAsSingleValue(E->getBase()).getValue();
+
+  // Emit the indices.
+  //
+  // FIXME: This is apparently not true for Swift @objc subscripts.
+  // Objective-C subscripts only ever have a single parameter.
+  Expr *IndexExpr = E->getArgs()->getUnaryExpr();
+  assert(IndexExpr);
+
+  PreparedArguments IndexArgs(
+      FunctionType::Param(IndexExpr->getType()->getCanonicalType()));
+  IndexArgs.add(E, SGF.emitRValue(IndexExpr));
+
+  return SGF.emitDynamicSubscriptGetterApply(
+      E, Operand, E->getMember(), std::move(IndexArgs),
+      E->getType()->getCanonicalType(), C);
 }
 
 

lib/SILGen/SILGenFunction.h

@@ -1755,8 +1755,11 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
                               ConcreteDeclRef memberRef, CanType refTy,
                               SGFContext C);
 
-  /// Emit a dynamic subscript.
-  RValue emitDynamicSubscriptExpr(DynamicSubscriptExpr *e, SGFContext c);
+  /// Emit a dynamic subscript getter application.
+  RValue emitDynamicSubscriptGetterApply(SILLocation loc, SILValue operand,
+                                         ConcreteDeclRef subscriptRef,
+                                         PreparedArguments &&indexArgs,
+                                         CanType resultTy, SGFContext C);
 
   /// Open up the given existential expression and emit its
   /// subexpression in a caller-specified manner.