Merge pull request #66196 from gottesmm/release-5.9-more-stuff-2

[5.9] More batched changes

Author: gottesmm

include/swift/AST/DiagnosticsSIL.def

@@ -758,11 +758,10 @@ ERROR(sil_movechecking_value_used_after_consume, none,
       "'%0' used after consume", (StringRef))
 ERROR(sil_movechecking_guaranteed_value_consumed, none,
       "'%0' is borrowed and cannot be consumed", (StringRef))
-
-// FIXME: this diagnostic shouldn't ever be emitted now. rdar://109742587 (closures may still try to consume captures, e.g., borrowed parameters)
-ERROR(sil_movechecking_guaranteed_value_captured_by_closure, none,
-      "'%0' is borrowed and cannot be consumed by closure capture", (StringRef))
-
+ERROR(sil_movechecking_borrowed_parameter_captured_by_closure, none,
+      "'%0' cannot be captured by an escaping closure since it is a borrowed "
+      "parameter",
+      (StringRef))
 ERROR(sil_movechecking_capture_consumed, none,
       "noncopyable '%0' cannot be consumed when captured by a closure", (StringRef))
 ERROR(sil_movechecking_inout_not_reinitialized_before_end_of_function, none,

include/swift/SIL/SILFunctionConventions.h

@@ -371,6 +371,11 @@ class SILFunctionConventions {
     return getNumIndirectSILResults();
   }
 
+  /// Returns the index of self.
+  unsigned getSILArgIndexOfSelf() const {
+    return getSILArgIndexOfFirstParam() + getNumParameters() - 1;
+  }
+
   /// Get the index into formal indirect results corresponding to the given SIL
   /// indirect result argument index.
   unsigned getIndirectFormalResultIndexForSILArg(unsigned argIdx) const {

include/swift/SIL/SILMoveOnlyDeinit.h

@@ -63,7 +63,12 @@ class SILMoveOnlyDeinit final : public SILAllocated<SILMoveOnlyDeinit> {
 
   SILFunction *getImplementation() const { return funcImpl; }
 
-  bool isSerialized() const { return serialized; }
+  IsSerialized_t isSerialized() const {
+    return serialized ? IsSerialized : IsNotSerialized;
+  }
+  void setSerialized(IsSerialized_t inputSerialized) {
+    serialized = inputSerialized ? 1 : 0;
+  }
 
   void print(llvm::raw_ostream &os, bool verbose) const;
   void dump() const;

include/swift/SILOptimizer/Utils/CanonicalizeOSSALifetime.h

@@ -319,10 +319,9 @@ class CanonicalizeOSSALifetime final {
     liveness->initializeDef(getCurrentDef());
   }
 
-  void invalidateLiveness() {
+  void clear() {
     consumingBlocks.clear();
     debugValues.clear();
-    liveness->invalidate();
     discoveredBlocks.clear();
   }
 

lib/IRGen/GenType.cpp

@@ -2887,19 +2887,26 @@ static bool tryEmitDeinitCall(IRGenFunction &IGF,
                           llvm::function_ref<void ()> indirectCleanup) {
   auto ty = T.getASTType();
   auto nominal = ty->getAnyNominal();
+
   // We are only concerned with move-only type deinits here.
   if (!nominal || !nominal->getValueTypeDestructor()) {
     return false;
   }
-  
-  auto deinit = IGF.getSILModule().lookUpMoveOnlyDeinit(nominal);
-  assert(deinit && "type has a deinit declared in AST but SIL deinit record is not present!");
-    
+
+  auto deinitTable = IGF.getSILModule().lookUpMoveOnlyDeinit(nominal);
+
+  // If we do not have a deinit table, call the value witness instead.
+  if (!deinitTable) {
+    irgen::emitDestroyCall(IGF, T, indirect());
+    indirectCleanup();
+    return true;
+  }
+
   // The deinit should take a single value parameter of the nominal type, either
   // by @owned or indirect @in convention.
-  auto deinitFn = IGF.IGM.getAddrOfSILFunction(deinit->getImplementation(),
+  auto deinitFn = IGF.IGM.getAddrOfSILFunction(deinitTable->getImplementation(),
                                                NotForDefinition);
-  auto deinitTy = deinit->getImplementation()->getLoweredFunctionType();
+  auto deinitTy = deinitTable->getImplementation()->getLoweredFunctionType();
   auto deinitFP = FunctionPointer::forDirect(IGF.IGM, deinitFn,
                                              nullptr, deinitTy);
   assert(deinitTy->getNumParameters() == 1

lib/SILGen/ArgumentSource.h

@@ -280,7 +280,7 @@ class ArgumentSource {
 
   ArgumentSource copyForDiagnostics() const;
 
-  void dump() const;
+  LLVM_DUMP_METHOD void dump() const;
   void dump(raw_ostream &os, unsigned indent = 0) const;
 
 private:

lib/SILGen/SILGen.cpp

@@ -1079,11 +1079,6 @@ void SILGenModule::emitFunctionDefinition(SILDeclRef constant, SILFunction *f) {
     preEmitFunction(constant, f, loc);
     PrettyStackTraceSILFunction X("silgen emitDeallocatingDestructor", f);
     SILGenFunction(*this, *f, dd).emitDeallocatingDestructor(dd);
-
-    // If we have a move only type, create the table for this type.
-    if (nom->isMoveOnly())
-      SILMoveOnlyDeinit::create(f->getModule(), nom, IsNotSerialized, f);
-
     postEmitFunction(constant, f);
     return;
   }

lib/SILGen/SILGen.h

@@ -459,6 +459,9 @@ class LLVM_LIBRARY_VISIBILITY SILGenModule : public ASTVisitor<SILGenModule> {
                                     SILFunction *jvp, SILFunction *vjp,
                                     const DeclAttribute *diffAttr);
 
+  /// Emit a deinit table for a noncopyable type.
+  void emitNonCopyableTypeDeinitTable(NominalTypeDecl *decl);
+
   /// Known functions for bridging.
   SILDeclRef getStringToNSStringFn();
   SILDeclRef getNSStringToStringFn();

lib/SILGen/SILGenApply.cpp

@@ -3029,7 +3029,8 @@ static StorageRefResult findStorageReferenceExprForBorrow(Expr *e) {
       return result.withTransitiveRoot(te);
 
   } else if (auto ioe = dyn_cast<InOutExpr>(e)) {
-    return ioe;
+    if (auto result = findStorageReferenceExprForBorrow(ioe->getSubExpr()))
+      return result.withTransitiveRoot(ioe);
   }
 
   return StorageRefResult();
@@ -3049,6 +3050,24 @@ Expr *ArgumentSource::findStorageReferenceExprForMoveOnly(
     sawLoad = true;
   }
 
+  // If we have a subscript, strip it off and make sure that our base is
+  // something that we can process. If we do and we succeed below, we return the
+  // subscript instead.
+  SubscriptExpr *subscriptExpr = nullptr;
+  if ((subscriptExpr = dyn_cast<SubscriptExpr>(argExpr))) {
+    auto *decl = cast<SubscriptDecl>(subscriptExpr->getDecl().getDecl());
+    if (decl->getReadImpl() != ReadImplKind::Read) {
+      subscriptExpr = nullptr;
+    } else {
+      argExpr = subscriptExpr->getBase();
+    }
+
+    // If there's a load on the base of the subscript expr, look past it.
+    if (auto *li = dyn_cast<LoadExpr>(argExpr)) {
+      argExpr = li->getSubExpr();
+    }
+  }
+
   // If we're consuming instead, then the load _must_ have been there.
   if (kind == StorageReferenceOperationKind::Consume && !sawLoad)
     return nullptr;
@@ -3097,6 +3116,12 @@ Expr *ArgumentSource::findStorageReferenceExprForMoveOnly(
   // has a move only base.
   (void)std::move(*this).asKnownExpr();
 
+  // If we saw a subscript expr and the base of the subscript expr passed our
+  // tests above, we can emit the call to the subscript directly as a borrowed
+  // lvalue. Return the subscript expr here so that we emit it appropriately.
+  if (subscriptExpr)
+    return subscriptExpr;
+
   return result.getTransitiveRoot();
 }
 

lib/SILGen/SILGenDecl.cpp

@@ -1958,13 +1958,19 @@ InitializationPtr SILGenFunction::emitLocalVariableWithCleanup(
 std::unique_ptr<TemporaryInitialization>
 SILGenFunction::emitTemporary(SILLocation loc, const TypeLowering &tempTL) {
   SILValue addr = emitTemporaryAllocation(loc, tempTL.getLoweredType());
+  if (addr->getType().isMoveOnly())
+    addr = B.createMarkMustCheckInst(
+        loc, addr, MarkMustCheckInst::CheckKind::ConsumableAndAssignable);
   return useBufferAsTemporary(addr, tempTL);
 }
 
 std::unique_ptr<TemporaryInitialization>
 SILGenFunction::emitFormalAccessTemporary(SILLocation loc,
                                           const TypeLowering &tempTL) {
   SILValue addr = emitTemporaryAllocation(loc, tempTL.getLoweredType());
+  if (addr->getType().isMoveOnly())
+    addr = B.createMarkMustCheckInst(
+        loc, addr, MarkMustCheckInst::CheckKind::ConsumableAndAssignable);
   CleanupHandle cleanup =
       enterDormantFormalAccessTemporaryCleanup(addr, loc, tempTL);
   return std::unique_ptr<TemporaryInitialization>(