Fix the emission of r-value pointer conversions to delay the

conversions and extend lifetimes over the call.

Apply this logic to string-to-pointer conversions as well as
array-to-pointer conversions.

Fix the AST verifier to not blow up on optional pointer conversions,
and make sure we SILGen them correctly.  There's still an AST bug
here, but I'll fix that in a follow-up patch.

Author: rjmccall

include/swift/SIL/SILType.h

@@ -521,6 +521,9 @@ class SILType {
   /// Get the builtin word type as a SILType;
   static SILType getBuiltinWordType(const ASTContext &C);
 
+  /// Given a value type, return an optional type wrapping it.
+  static SILType getOptionalType(SILType valueType);
+
   /// Get the standard exception type.
   static SILType getExceptionType(const ASTContext &C);
 

lib/AST/ASTVerifier.cpp

@@ -1361,19 +1361,53 @@ class Verifier : public ASTWalker {
     }
 
     void updateExprToPointerWhitelist(Expr *Base, Expr *Arg) {
-      auto handleSubExpr = [&](Expr *SubExpr) {
-        // if we have an inject into optional, strip it off.
-        if (auto *InjectIntoOpt = dyn_cast<InjectIntoOptionalExpr>(SubExpr)) {
-          SubExpr = InjectIntoOpt->getSubExpr();
+      auto handleSubExpr = [&](Expr *origSubExpr) {
+        auto subExpr = origSubExpr;
+        unsigned optionalDepth = 0;
+
+        auto checkIsBindOptional = [&](Expr *expr) {
+          for (unsigned depth = optionalDepth; depth; --depth) {
+            if (auto bind = dyn_cast<BindOptionalExpr>(expr)) {
+              expr = bind->getSubExpr();
+            } else {
+              Out << "malformed optional pointer conversion\n";
+              origSubExpr->print(Out);
+              Out << '\n';
+              abort();
+            }
+          }
+        };
+
+        // These outer entities will be interleaved in multi-level optionals.
+        while (true) {
+          // Look through optional evaluations.
+          if (auto *optionalEval = dyn_cast<OptionalEvaluationExpr>(subExpr)) {
+            subExpr = optionalEval->getSubExpr();
+            optionalDepth++;
+            continue;
+          }
+
+          // Look through injections into Optional<Pointer>.
+          if (auto *injectIntoOpt = dyn_cast<InjectIntoOptionalExpr>(subExpr)) {
+            subExpr = injectIntoOpt->getSubExpr();
+            continue;
+          }
+
+          break;
         }
 
-        if (auto *InOutToPtr = dyn_cast<InOutToPointerExpr>(SubExpr)) {
-          WhitelistedInOutToPointerExpr.insert(InOutToPtr);
+        // Whitelist inout-to-pointer conversions.
+        if (auto *inOutToPtr = dyn_cast<InOutToPointerExpr>(subExpr)) {
+          WhitelistedInOutToPointerExpr.insert(inOutToPtr);
+          checkIsBindOptional(inOutToPtr->getSubExpr());
           return;
         }
 
-        if (auto *ArrayToPtr = dyn_cast<ArrayToPointerExpr>(SubExpr)) {
-          WhitelistedArrayToPointerExpr.insert(ArrayToPtr);
+        // Whitelist array-to-pointer conversions.
+        if (auto *arrayToPtr = dyn_cast<ArrayToPointerExpr>(subExpr)) {
+          WhitelistedArrayToPointerExpr.insert(arrayToPtr);
+          checkIsBindOptional(arrayToPtr->getSubExpr());
+          return;
         }
       };
 

lib/SIL/SILType.cpp

@@ -64,6 +64,13 @@ SILType SILType::getBuiltinWordType(const ASTContext &C) {
   return getPrimitiveObjectType(CanType(BuiltinIntegerType::getWordType(C)));
 }
 
+SILType SILType::getOptionalType(SILType type) {
+  auto &ctx = type.getSwiftRValueType()->getASTContext();
+  auto optType = BoundGenericEnumType::get(ctx.getOptionalDecl(), Type(),
+                                           { type.getSwiftRValueType() });
+  return getPrimitiveType(CanType(optType), type.getCategory());
+}
+
 bool SILType::isTrivial(SILModule &M) const {
   return M.getTypeLowering(*this).isTrivial();
 }

lib/SILGen/ManagedValue.cpp

@@ -145,6 +145,26 @@ ManagedValue ManagedValue::formalAccessBorrow(SILGenFunction &SGF,
   return SGF.emitFormalEvaluationManagedBeginBorrow(loc, getValue());
 }
 
+ManagedValue ManagedValue::materialize(SILGenFunction &SGF,
+                                       SILLocation loc) const {
+  auto temporary = SGF.emitTemporaryAllocation(loc, getType());
+  bool hadCleanup = hasCleanup();
+
+  // The temporary memory is +0 if the value was.
+  if (hadCleanup) {
+    SGF.B.emitStoreValueOperation(loc, forward(SGF), temporary,
+                                  StoreOwnershipQualifier::Init);
+
+    // SEMANTIC SIL TODO: This should really be called a temporary LValue.
+    return ManagedValue::forOwnedAddressRValue(temporary,
+                                          SGF.enterDestroyCleanup(temporary));
+  } else {
+    auto object = SGF.emitManagedBeginBorrow(loc, getValue());
+    SGF.emitManagedStoreBorrow(loc, object.getValue(), temporary);
+    return ManagedValue::forBorrowedAddressRValue(temporary);
+  }
+}
+
 void ManagedValue::print(raw_ostream &os) const {
   if (SILValue v = getValue()) {
     v->print(os);

lib/SILGen/ManagedValue.h

@@ -270,6 +270,10 @@ class ManagedValue {
     return isLValue() ? *this : ManagedValue::forUnmanaged(getValue());
   }
 
+  /// Given a scalar value, materialize it into memory with the
+  /// exact same level of cleanup it had before.
+  ManagedValue materialize(SILGenFunction &SGF, SILLocation loc) const;
+
   /// Disable the cleanup for this value.
   void forwardCleanup(SILGenFunction &SGF) const;