Merge pull request #8441 from gottesmm/rdar_31313534

Author: swift-ci

lib/SILGen/Cleanup.cpp

@@ -276,3 +276,9 @@ void CleanupManager::dump(CleanupHandle handle) const {
   llvm::errs() << "CLEANUP DEPTH: " << handle.getDepth() << "\n";
   stackCleanup.dump(SGF);
 }
+
+void CleanupManager::checkIterator(CleanupHandle handle) const {
+#ifndef NDEBUG
+  stack.checkIterator(handle);
+#endif
+}

lib/SILGen/Cleanup.h

@@ -209,6 +209,9 @@ class LLVM_LIBRARY_VISIBILITY CleanupManager {
 
   /// Dump the given cleanup handle if it is on the current stack.
   void dump(CleanupHandle handle) const;
+
+  /// Verify that the given cleanup handle is valid.
+  void checkIterator(CleanupHandle handle) const;
 };
 
 /// An RAII object that allows the state of a cleanup to be

lib/SILGen/FormalEvaluation.cpp

@@ -23,6 +23,26 @@ using namespace Lowering;
 
 void FormalAccess::_anchor() {}
 
+void FormalAccess::verify(SILGenFunction &SGF) const {
+#ifndef NDEBUG
+  // If this access was already finished, continue. This can happen if an
+  // owned formal access was forwarded.
+  if (isFinished()) {
+    assert(getKind() == FormalAccess::Owned &&
+           "Only owned formal accesses should be forwarded.");
+    // We can not check that our cleanup is actually dead since the cleanup
+    // may have been popped at this point and the stack may have new values.
+    return;
+  }
+
+  assert(!isFinished() && "Can not finish a formal access cleanup "
+         "twice");
+
+  // Now try to look up the cleanup handle of the formal access.
+  SGF.Cleanups.checkIterator(getCleanup());
+#endif
+}
+
 //===----------------------------------------------------------------------===//
 //                      Shared Borrow Formal Evaluation
 //===----------------------------------------------------------------------===//
@@ -141,6 +161,24 @@ void FormalEvaluationScope::popImpl() {
   context.pop(savedDepth.getValue());
 }
 
+void FormalEvaluationScope::verify() const {
+  // Check to see if there is anything going on here.
+  auto &context = SGF.FormalEvalContext;
+  using iterator = FormalEvaluationContext::iterator;
+
+  iterator unwrappedSavedDepth = context.find(savedDepth.getValue());
+  iterator iter = context.begin();
+  if (iter == unwrappedSavedDepth)
+    return;
+
+  // Then working down the stack until we visit unwrappedSavedDepth...
+  for (; iter != unwrappedSavedDepth; ++iter) {
+    // Grab the next evaluation verify that we can successfully access this
+    // formal access.
+    (*iter).verify(SGF);
+  }
+}
+
 //===----------------------------------------------------------------------===//
 //                         Formal Evaluation Context
 //===----------------------------------------------------------------------===//

lib/SILGen/FormalEvaluation.h

@@ -65,6 +65,8 @@ class FormalAccess {
 
   bool isFinished() const { return finished; }
 
+  void verify(SILGenFunction &SGF) const;
+
 protected:
   virtual void finishImpl(SILGenFunction &SGF) = 0;
 };
@@ -202,6 +204,10 @@ class FormalEvaluationScope {
   FormalEvaluationScope(FormalEvaluationScope &&o);
   FormalEvaluationScope &operator=(FormalEvaluationScope &&o) = delete;
 
+  /// Verify that we can successfully access all of the inner lexical scopes
+  /// that would be popped by this scope.
+  void verify() const;
+
 private:
   void popImpl();
 };

lib/SILGen/SILGenApply.cpp

@@ -1744,12 +1744,8 @@ RValue SILGenFunction::emitApply(ResultPlanPtr &&resultPlan,
   }
 
   // If there's a foreign error parameter, fill it in.
-  Optional<FormalEvaluationScope> errorTempWriteback;
   ManagedValue errorTemp;
   if (auto foreignError = calleeTypeInfo.foreignError) {
-    // Error-temporary emission may need writeback.
-    errorTempWriteback.emplace(*this);
-
     unsigned errorParamIndex =
         calleeTypeInfo.foreignError->getErrorParameterIndex();
 
@@ -1850,9 +1846,6 @@ RValue SILGenFunction::emitApply(ResultPlanPtr &&resultPlan,
   // TODO: maybe this should happen after managing the result if it's
   // not a result-checking convention?
   if (auto foreignError = calleeTypeInfo.foreignError) {
-    // Force immediate writeback to the error temporary.
-    errorTempWriteback.reset();
-
     bool doesNotThrow = (options & ApplyOptions::DoesNotThrow);
     emitForeignErrorCheck(loc, directResults, errorTemp,
                           doesNotThrow, *foreignError);
@@ -3644,6 +3637,8 @@ namespace {
     }
 
     RValue apply(SGFContext C = SGFContext()) {
+      initialWritebackScope.verify();
+
       assert(!applied && "already applied!");
 
       applied = true;
@@ -3664,12 +3659,12 @@ namespace {
                                 foreignError, foreignSelf, uncurryLevel, C);
 
       // End of the initial writeback scope.
+      initialWritebackScope.verify();
       initialWritebackScope.pop();
 
       // Then handle the remaining call sites.
       result = applyRemainingCallSites(std::move(result), formalType,
                                        foreignSelf, foreignError, C);
-
       return result;
     }
 
@@ -4231,9 +4226,10 @@ static CallEmission prepareApplyExpr(SILGenFunction &SGF, Expr *e) {
                         apply.AssumedPlusZeroSelf);
 
   // Apply 'self' if provided.
-  if (apply.SelfParam)
+  if (apply.SelfParam) {
     emission.addCallSite(RegularLocation(e), std::move(apply.SelfParam),
                          apply.SelfType->getCanonicalType(), /*throws*/ false);
+  }
 
   // Apply arguments from call sites, innermost to outermost.
   for (auto site = apply.CallSites.rbegin(), end = apply.CallSites.rend();
@@ -4246,7 +4242,8 @@ static CallEmission prepareApplyExpr(SILGenFunction &SGF, Expr *e) {
 }
 
 RValue SILGenFunction::emitApplyExpr(Expr *e, SGFContext c) {
-  return prepareApplyExpr(*this, e).apply(c);
+  CallEmission emission = prepareApplyExpr(*this, e);
+  return emission.apply(c);
 }
 
 RValue

test/Inputs/clang-importer-sdk/usr/include/Foundation.h

@@ -257,6 +257,9 @@ __attribute__((warn_unused_result)) NSString *NSStringToNSString(NSString *str);
 @interface NSURL : NSObject
 - (instancetype)URLWithString:(NSString *)URLString;
 + (instancetype)URLWithString:(NSString *)URLString;
+- (BOOL)getResourceValue:(out id _Nullable *)value
+                  forKey:(NSString *)key
+                   error:(out NSError *_Nullable *)error;
 @end
 
 @interface NSAttributedString : NSString

test/SILGen/foreign_errors.swift

@@ -298,3 +298,14 @@ func testPreservedResultInverted() throws {
 // CHECK-NOT: destroy_value
 // CHECK:   return {{%.+}} : $()
 // CHECK: [[ERROR_BB]]
+
+// Make sure that we do not crash when emitting the error value here.
+//
+// TODO: Add some additional filecheck tests.
+extension NSURL {
+  func resourceValue<T>(forKey key: String) -> T? {
+    var prop: AnyObject? = nil
+    _ = try? self.getResourceValue(&prop, forKey: key)
+    return prop as? T
+  }
+}