Merge pull request #3475 from jckarter/id-as-any-silgen

Preliminary SILGen and runtime support for id-as-Any.

Author: jckarter

include/swift/AST/KnownDecls.def

@@ -65,6 +65,9 @@ FUNC_DECL(ForceBridgeFromObjectiveCBridgeable,
 FUNC_DECL(ConditionallyBridgeFromObjectiveCBridgeable,
           "_conditionallyBridgeFromObjectiveC_bridgeable")
 
+FUNC_DECL(BridgeAnythingToObjectiveC,
+          "_bridgeAnythingToObjectiveC")
+
 FUNC_DECL(DidEnterMain, "_stdlib_didEnterMain")
 FUNC_DECL(DiagnoseUnexpectedNilOptional, "_diagnoseUnexpectedNilOptional")
 

lib/SILGen/SILGenBridging.cpp

@@ -20,6 +20,7 @@
 #include "swift/AST/ParameterList.h"
 #include "swift/Basic/Fallthrough.h"
 #include "swift/SIL/SILArgument.h"
+#include "swift/SIL/SILUndef.h"
 #include "swift/SIL/TypeLowering.h"
 
 using namespace swift;
@@ -280,13 +281,26 @@ static void buildFuncToBlockInvokeBody(SILGenFunction &gen,
                                 funcParam.getType()));
   }
 
+  CanType resultType;
+  SILValue indirectResult;
+
+  if (funcTy->getNumAllResults() == 0)
+    resultType = TupleType::getEmpty(gen.SGM.getASTContext());
+  else {
+    auto result = funcTy->getSingleResult();
+    resultType = result.getType();
+
+    auto &tl = gen.getTypeLowering(result.getSILType());
+    if (tl.isAddressOnly()) {
+      assert(result.getConvention() == ResultConvention::Indirect);
+      assert(resultType->isAny() &&
+             "Should not be trying to bridge anything except for Any here");
+    }
+  }
+
   // Call the native function.
-  assert(!funcTy->hasIndirectResults()
-         && "block thunking func with indirect result not supported");
-  assert(funcTy->getNumDirectResults() <= 1
-         && "block thunking func with multiple results not supported");
   ManagedValue result = gen.emitMonomorphicApply(loc, fn, args,
-                         funcTy->getSILResult().getSwiftRValueType(),
+                                                 resultType,
                                                  ApplyOptions::None,
                                                  None, None)
     .getAsSingleValue(gen, loc);
@@ -437,16 +451,43 @@ static ManagedValue emitNativeToCBridgedNonoptionalValue(SILGenFunction &gen,
     return gen.emitNativeToBridgedError(loc, v, loweredBridgedTy);
   }
 
-  return v;
+  // Fall back to dynamic Any-to-id bridging.
+  // The destination type should be AnyObject in this case.
+  //
+  // TODO: Should only get here if -enable-id-as-any is active.
+  assert(gen.getASTContext().LangOpts.EnableIdAsAny
+         && loweredBridgedTy->isEqual(
+              gen.getASTContext().getProtocol(KnownProtocolKind::AnyObject)
+                ->getDeclaredType()));
+
+  // If the input argument is known to be an existential, save the runtime
+  // some work by opening it.
+  if (loweredNativeTy->isExistentialType()) {
+    auto openedTy = ArchetypeType::getOpened(loweredNativeTy);
+    
+    auto openedExistential = gen.emitOpenExistential(loc, v, openedTy,
+                                                 gen.getLoweredType(openedTy));
+    v = openedExistential.Value;
+    loweredNativeTy = openedTy;
+  }
+
+  // Call into the stdlib intrinsic.
+  if (auto bridgeAnything =
+        gen.getASTContext().getBridgeAnythingToObjectiveC(nullptr)) {
+    Substitution sub(loweredNativeTy, {});
+    return gen.emitApplyOfLibraryIntrinsic(loc, bridgeAnything, sub, v,
+                                           SGFContext())
+      .getAsSingleValue(gen, loc);
+  }
+  
+  // Shouldn't get here unless the standard library is busted.
+  return gen.emitUndef(loc, bridgedTy);
 }
 
 static ManagedValue emitNativeToCBridgedValue(SILGenFunction &gen,
                                               SILLocation loc,
                                               ManagedValue v,
                                               SILType bridgedTy) {
-  assert(v.getType().isLoadable(gen.F.getModule()) &&
-         "Cannot bridge address-only types");
-
   CanType loweredBridgedTy = bridgedTy.getSwiftRValueType();
   CanType loweredNativeTy = v.getType().getSwiftRValueType();
   if (loweredNativeTy == loweredBridgedTy)
@@ -472,9 +513,9 @@ static ManagedValue emitNativeToCBridgedValue(SILGenFunction &gen,
 }
 
 ManagedValue SILGenFunction::emitNativeToBridgedValue(SILLocation loc,
-                                                      ManagedValue v,
-                                                SILFunctionTypeRepresentation destRep,
-                                                      CanType loweredBridgedTy){
+                                          ManagedValue v,
+                                          SILFunctionTypeRepresentation destRep,
+                                          CanType loweredBridgedTy){
   switch (getSILFunctionLanguage(destRep)) {
   case SILFunctionLanguage::Swift:
     // No additional bridging needed for native functions.
@@ -499,15 +540,29 @@ static void buildBlockToFuncThunkBody(SILGenFunction &gen,
 
   SmallVector<ManagedValue, 4> args;
   SILBasicBlock *entry = &*gen.F.begin();
+
+  CanType resultType;
+  SILValue indirectResult;
+
+  if (funcTy->getNumAllResults() == 0)
+    resultType = TupleType::getEmpty(gen.SGM.getASTContext());
+  else {
+    auto result = funcTy->getSingleResult();
+    resultType = result.getType();
+
+    auto &tl = gen.getTypeLowering(result.getSILType());
+    if (tl.isAddressOnly()) {
+      assert(result.getConvention() == ResultConvention::Indirect);
+
+      indirectResult = new (gen.SGM.M) SILArgument(entry, result.getSILType());
+    }
+  }
+
   for (unsigned i : indices(funcTy->getParameters())) {
     auto &param = funcTy->getParameters()[i];
     auto &blockParam = blockTy->getParameters()[i];
 
     auto &tl = gen.getTypeLowering(param.getSILType());
-    assert((tl.isTrivial()
-              ? param.getConvention() == ParameterConvention::Direct_Unowned
-              : param.getConvention() == ParameterConvention::Direct_Owned)
-           && "nonstandard conventions for native functions not implemented");
     SILValue v = new (gen.SGM.M) SILArgument(entry, param.getSILType());
     auto mv = gen.emitManagedRValueWithCleanup(v, tl);
     args.push_back(gen.emitNativeToBridgedValue(loc, mv,
@@ -522,26 +577,22 @@ static void buildBlockToFuncThunkBody(SILGenFunction &gen,
   ManagedValue block = gen.emitManagedRValueWithCleanup(blockV);
 
   // Call the block.
-  assert(!funcTy->hasIndirectResults()
-         && "block thunking func with indirect result not supported");
   ManagedValue result = gen.emitMonomorphicApply(loc, block, args,
-                         funcTy->getSILResult().getSwiftRValueType(),
-                         ApplyOptions::None,
-                         /*override CC*/ SILFunctionTypeRepresentation::Block,
-                         /*foreign error*/ None)
+                           resultType,
+                           ApplyOptions::None,
+                           /*override CC*/ SILFunctionTypeRepresentation::Block,
+                           /*foreign error*/ None)
     .getAsSingleValue(gen, loc);
 
   // Return the result at +1.
-#ifndef NDEBUG
-  for (auto result : funcTy->getDirectResults()) {
-    assert((gen.getTypeLowering(result.getSILType()).isTrivial()
-             ? result.getConvention() == ResultConvention::Unowned
-             : result.getConvention() == ResultConvention::Owned)
-           && "nonstandard conventions for return not implemented");
+  auto r = result.forward(gen);
+
+  if (indirectResult) {
+    gen.B.createCopyAddr(loc, r, indirectResult,
+                         IsTake, IsInitialization);
+    r = gen.B.createTuple(loc, funcTy->getSILResult(), {});
   }
-#endif
 
-  auto r = result.forward(gen);
   scope.pop();
   gen.B.createReturn(loc, r);
 }
@@ -584,9 +635,6 @@ static ManagedValue emitCBridgedToNativeValue(SILGenFunction &gen,
                                               SILLocation loc,
                                               ManagedValue v,
                                               SILType nativeTy) {
-  assert(nativeTy.isLoadable(gen.F.getModule()) &&
-         "Cannot bridge address-only types");
-
   CanType loweredNativeTy = nativeTy.getSwiftRValueType();
   CanType loweredBridgedTy = v.getType().getSwiftRValueType();
   if (loweredNativeTy == loweredBridgedTy)
@@ -640,8 +688,29 @@ static ManagedValue emitCBridgedToNativeValue(SILGenFunction &gen,
   }
 
   // Bridge NSError to Error.
-  if (loweredBridgedTy == gen.SGM.Types.getNSErrorType()) {
+  if (loweredBridgedTy == gen.SGM.Types.getNSErrorType())
     return gen.emitBridgedToNativeError(loc, v);
+
+  // id-to-Any bridging.
+  if (loweredNativeTy->isAny()) {
+    assert(loweredBridgedTy->isEqual(
+      gen.getASTContext().getProtocol(KnownProtocolKind::AnyObject)
+        ->getDeclaredType())
+      && "Any should bridge to AnyObject");
+    
+    // Open the type of the reference and use it to build an Any.
+    auto openedTy = ArchetypeType::getOpened(loweredBridgedTy);
+    auto openedSILTy = SILType::getPrimitiveObjectType(openedTy);
+    // TODO: Ever need to handle +0 values here?
+    assert(v.hasCleanup());
+    auto opened = gen.B.createOpenExistentialRef(loc, v.forward(gen),
+                                                 openedSILTy);
+    auto result = gen.emitTemporaryAllocation(loc, nativeTy);
+    auto resultVal = gen.B.createInitExistentialAddr(loc, result,
+                                                     openedTy, openedSILTy,
+                                                     {});
+    gen.B.createStore(loc, opened, resultVal);
+    return gen.emitManagedRValueWithCleanup(result);
   }
 
   return v;
@@ -779,13 +848,9 @@ static SILFunctionType *emitObjCThunkArguments(SILGenFunction &gen,
     assert(foreignError && "couldn't find foreign error convention!");
   }
 
-  // Emit the indirect result arguments, if any.
-  // FIXME: we're just assuming that these match up exactly?
-  for (auto indirectResult : objcFnTy->getIndirectResults()) {
-    SILType argTy = indirectResult.getSILType();
-    auto arg = new (gen.F.getModule()) SILArgument(gen.F.begin(), argTy);
-    args.push_back(arg);
-  }
+  // We don't know what to do with indirect results from the Objective-C side.
+  assert(objcFnTy->getNumIndirectResults() == 0 &&
+         "Objective-C methods cannot have indirect results");
 
   // Emit the other arguments, taking ownership of arguments if necessary.
   auto inputs = objcFnTy->getParameters();
@@ -839,7 +904,13 @@ static SILFunctionType *emitObjCThunkArguments(SILGenFunction &gen,
          "didn't find foreign error slot");
 
   // Bridge the input types.
-  Scope scope(gen.Cleanups, CleanupLocation::get(loc));
+
+  // FIXME: We really want alloc_stacks to outlive this scope, because
+  // bridging id-to-Any requires allocating an Any which gets passed to
+  // the native entry point.
+
+  // Scope scope(gen.Cleanups, CleanupLocation::get(loc));
+
   assert(bridgedArgs.size() == nativeInputs.size());
   for (unsigned i = 0, size = bridgedArgs.size(); i < size; ++i) {
     SILType argTy = swiftFnTy->getParameters()[i].getSILType();
@@ -864,28 +935,43 @@ static SILFunctionType *emitObjCThunkArguments(SILGenFunction &gen,
 void SILGenFunction::emitNativeToForeignThunk(SILDeclRef thunk) {
   assert(thunk.isForeign);
   SILDeclRef native = thunk.asForeign(false);
-
+  auto nativeInfo = getConstantInfo(native);
+  auto subs = F.getForwardingSubstitutions();
+  auto substTy = nativeInfo.SILFnType->substGenericArgs(
+    SGM.M, SGM.M.getSwiftModule(), subs);
+  SILType substSILTy = SILType::getPrimitiveObjectType(substTy);
+  
   auto loc = thunk.getAsRegularLocation();
   loc.markAutoGenerated();
   Scope scope(Cleanups, CleanupLocation::get(loc));
 
-  // Bridge the arguments.
+  // If we are bridging a Swift method with an Any return value, create a
+  // stack allocation to hold the result, since Any is address-only.
   SmallVector<SILValue, 4> args;
+
+  if (substTy->getNumIndirectResults() > 0) {
+    SILResultInfo indirectResult = substTy->getSingleResult();
+    assert(indirectResult.getType()->isAny() &&
+           "Should not be trying to bridge anything except for Any here");
+    args.push_back(emitTemporaryAllocation(loc, indirectResult.getSILType()));
+  }
+
+  // Now, enter a cleanup used for bridging the arguments. Note that if we
+  // have an indirect result, it must be outside of this scope, otherwise
+  // we will deallocate it too early.
+  Scope argScope(Cleanups, CleanupLocation::get(loc));
+
+  // Bridge the arguments.
   Optional<ForeignErrorConvention> foreignError;
   SILValue foreignErrorSlot;
   auto objcFnTy = emitObjCThunkArguments(*this, loc, thunk, args,
                                          foreignErrorSlot, foreignError);
-  auto nativeInfo = getConstantInfo(native);
   auto swiftResultTy =
     F.mapTypeIntoContext(nativeInfo.SILFnType->getSILResult());
   auto objcResultTy = objcFnTy->getSILResult();
 
   // Call the native entry point.
   SILValue nativeFn = emitGlobalFunctionRef(loc, native, nativeInfo);
-  auto subs = F.getForwardingSubstitutions();
-  auto substTy = nativeInfo.SILFnType->substGenericArgs(
-    SGM.M, SGM.M.getSwiftModule(), subs);
-  SILType substSILTy = SILType::getPrimitiveObjectType(substTy);
 
   CanType bridgedResultType = objcResultTy.getSwiftRValueType();
 
@@ -896,9 +982,14 @@ void SILGenFunction::emitNativeToForeignThunk(SILDeclRef thunk) {
     result = B.createApply(loc, nativeFn, substSILTy,
                            swiftResultTy, subs, args);
 
-    // Leave the scope immediately.  This isn't really necessary; it
-    // just limits lifetimes a little bit more.
-    scope.pop();
+    if (substTy->hasIndirectResults()) {
+      assert(substTy->getNumAllResults() == 1);
+      result = args[0];
+    }
+
+    // Leave the argument cleanup scope immediately.  This isn't really
+    // necessary; it just limits lifetimes a little bit more.
+    argScope.pop();
 
     // Now bridge the return value.
     result = emitBridgeReturnValue(*this, loc, result,
@@ -946,9 +1037,10 @@ void SILGenFunction::emitNativeToForeignThunk(SILDeclRef thunk) {
     result = contBB->createBBArg(objcResultTy);
 
     // Leave the scope now.
-    scope.pop();
+    argScope.pop();
   }
 
+  scope.pop();
   B.createReturn(loc, result);
 }
 

lib/SILGen/SILGenExpr.cpp

@@ -3517,16 +3517,11 @@ ManagedValue SILGenFunction::emitRValueAsSingleValue(Expr *E, SGFContext C) {
   return std::move(rv).getAsSingleValue(*this, E);
 }
 
-static ManagedValue emitUndef(SILGenFunction &gen, SILLocation loc,
-                              const TypeLowering &undefTL) {
-  SILValue undef = SILUndef::get(undefTL.getLoweredType(), gen.SGM.M);
-  return gen.emitManagedRValueWithCleanup(undef, undefTL);
-}
-
 ManagedValue SILGenFunction::emitUndef(SILLocation loc, Type type) {
-  return ::emitUndef(*this, loc, getTypeLowering(type));
+  return emitUndef(loc, getLoweredType(type));
 }
 
 ManagedValue SILGenFunction::emitUndef(SILLocation loc, SILType type) {
-  return ::emitUndef(*this, loc, getTypeLowering(type));
+  SILValue undef = SILUndef::get(type, SGM.M);
+  return ManagedValue::forUnmanaged(undef);
 }

stdlib/public/core/BridgeObjectiveC.swift

@@ -193,6 +193,35 @@ func _bridgeToObjectiveCUnconditionalAutorelease<T>(_ x: T) -> AnyObject
 @_silgen_name("_swift_bridgeNonVerbatimToObjectiveC")
 func _bridgeNonVerbatimToObjectiveC<T>(_ x: T) -> AnyObject?
 
+/// Bridge an arbitrary value to an Objective-C object.
+///
+/// - If `T` is a class type, it is always bridged verbatim, the function
+///   returns `x`;
+///
+/// - otherwise, `T` conforms to `_ObjectiveCBridgeable`:
+///   + if `T._isBridgedToObjectiveC()` returns `false`, then
+///     we fall back to boxing (below);
+///   + otherwise, returns the result of `x._bridgeToObjectiveC()`;
+///
+/// - otherwise, we use **boxing** to bring the value into Objective-C.
+///   The value is wrapped in an instance of a private Objective-C class
+///   that is `id`-compatible and dynamically castable back to the type of
+///   the boxed value, but is otherwise opaque.
+///
+/// TODO: This should subsume `_bridgeToObjectiveC` above.
+/// COMPILER_INTRINSIC
+public func _bridgeAnythingToObjectiveC<T>(_ x: T) -> AnyObject {
+  if _fastPath(_isClassOrObjCExistential(T.self)) {
+    return unsafeBitCast(x, to: AnyObject.self)
+  }
+  return _bridgeAnythingNonVerbatimToObjectiveC(x)
+}
+
+// TODO: This should subsume `_bridgeNonVerbatimToObjectiveC` above.
+/// COMPILER_INTRINSIC
+@_silgen_name("_swift_bridgeAnythingNonVerbatimToObjectiveC")
+public func _bridgeAnythingNonVerbatimToObjectiveC<T>(_ x: T) -> AnyObject
+
 /// Convert `x` from its Objective-C representation to its Swift
 /// representation.
 ///
@@ -523,4 +552,5 @@ extension AutoreleasingUnsafeMutablePointer {
     Builtin.unreachable()
   }
 }
+
 #endif