Implement a syntactic peephole to recognize explicit bridging

conversions that reverse an implicit conversion done to align
foreign declarations with their imported types.

For example, consider an Objective-C method that returns an NSString*:
  - (nonnull NSString*) foo;
This will be imported into Swift as a method returning a String:
  func foo() -> String
A call to this method will implicitly convert the result to String
behind the scenes.  If the user then casts the result back to NSString*,
that would normally be compiled as an additional conversion.  The
compiler cannot simply eliminate the conversion because that is not
necessarily semantically equivalent.

This peephole recognizes as-casts that immediately reverse a bridging
conversion as a special case and gives them special power to eliminate
both conversions.  For example, 'foo() as NSString' will simply return
the original return value.  In addition to call results, this also
applies to call arguments, property accesses, and subscript accesses.

Author: rjmccall

lib/SILGen/Conversion.h

@@ -29,13 +29,16 @@ namespace Lowering {
 class Conversion {
 public:
   enum KindTy {
-    /// An implicit bridging conversion to a foreign type.
+    /// A bridging conversion to a foreign type.
     BridgeToObjC,
 
-    /// An implicit bridging conversion from a foreign type.
+    /// A bridging conversion to a foreign type following a force.
+    ForceAndBridgeToObjC,
+
+    /// A bridging conversion from a foreign type.
     BridgeFromObjC,
 
-    /// An implicit bridging conversion for a function result.
+    /// A bridging conversion for a function result.
     BridgeResultFromObjC,
 
     /// An erasure to Any (possibly wrapped in optional conversions).
@@ -73,6 +76,7 @@ class Conversion {
   static int getStorageIndexForKind(KindTy kind) {
     switch (kind) {
     case BridgeToObjC:
+    case ForceAndBridgeToObjC:
     case BridgeFromObjC:
     case BridgeResultFromObjC:
     case AnyErasure:
@@ -155,21 +159,63 @@ class Conversion {
   ManagedValue emit(SILGenFunction &SGF, SILLocation loc,
                     ManagedValue source, SGFContext ctxt) const;
 
-  Optional<Conversion> tryPeepholeOptionalInjection() const;
+  /// Try to form a conversion that does an optional injection
+  /// or optional-to-optional conversion followed by this conversion.
+  Optional<Conversion>
+  adjustForInitialOptionalConversions(CanType newSourceType) const;
+
+  /// Try to form a conversion that does a force-value followed by
+  /// this conversion.
+  Optional<Conversion> adjustForInitialForceValue() const;
 
   void dump() const LLVM_ATTRIBUTE_USED;
   void print(llvm::raw_ostream &out) const;
 };
 
-bool canPeepholeConversions(SILGenFunction &SGF,
-                            const Conversion &outerConversion,
-                            const Conversion &innerConversion);
+/// Information about how to peephole two conversions.
+///
+/// This is really the private state of SILGenConvert.
+class ConversionPeepholeHint {
+public:
+  enum Kind : uint8_t {
+    /// The value will be exactly the right type.
+    Identity,
+
+    /// The value needs to be bridged to AnyObject (possibly optionally).
+    BridgeToAnyObject,
+
+    /// The value just needs to undergo a subtype conversion.
+    Subtype
+  };
+
+private:
+  Kind TheKind;
+  bool Forced;
+
+public:
+  ConversionPeepholeHint(Kind kind, bool forced)
+    : TheKind(kind), Forced(forced) {
+  }
+
+  Kind getKind() const { return TheKind; }
+
+  /// Does the value need to be forced before the conversion?
+  /// This comes up with result conversions where the result was imported
+  /// as non-optional, as well as with implicitly unwrapped optionals.
+  bool isForced() const { return Forced; }
+};
+
+Optional<ConversionPeepholeHint>
+canPeepholeConversions(SILGenFunction &SGF,
+                       const Conversion &outerConversion,
+                       const Conversion &innerConversion);
 
 ManagedValue emitPeepholedConversions(SILGenFunction &SGF, SILLocation loc,
                                       const Conversion &outerConversion,
                                       const Conversion &innerConversion,
+                                      ConversionPeepholeHint hint,
                                       SGFContext C,
-                   llvm::function_ref<ManagedValue(SGFContext)> produceValue);
+                                      ValueProducerRef produceValue);
 
 /// An initialization where we ultimately want to apply a conversion to
 /// the value before completing the initialization.
@@ -234,8 +280,7 @@ class ConvertingInitialization final : public Initialization {
   /// initialization.  The initialization will not yet be finished.
   bool tryPeephole(SILGenFunction &SGF, Expr *E, Conversion innerConversion);
   bool tryPeephole(SILGenFunction &SGF, SILLocation loc,
-                   Conversion innerConversion,
-                   llvm::function_ref<ManagedValue(SGFContext)> generate);
+                   Conversion innerConversion, ValueProducerRef producer);
   bool tryPeephole(SILGenFunction &SGF, SILLocation loc, ManagedValue value,
                    Conversion innerConversion);
 
@@ -247,6 +292,13 @@ class ConvertingInitialization final : public Initialization {
     State = Initialized;
   }
 
+  /// Given that an emitter was able to adjust the conversion when
+  /// emitting into this initialization, continue emission into the
+  /// new conversion.
+  ManagedValue emitWithAdjustedConversion(SILGenFunction &SGF, SILLocation loc,
+                                          Conversion adjustedConversion,
+                                          ValueProducerRef producer);
+
   /// Given the unconverted result, i.e. the result of emitting a
   /// value formally of the unconverted type with this initialization
   /// as the SGFContext, produce the converted result.

lib/SILGen/LValue.h

@@ -28,6 +28,7 @@
 namespace swift {
 namespace Lowering {
 
+class ArgumentSource;
 class LogicalPathComponent;
 class ManagedValue;
 class PhysicalPathComponent;
@@ -154,6 +155,12 @@ class PathComponent {
   TranslationPathComponent &asTranslation();
   const TranslationPathComponent &asTranslation() const;
 
+  /// Is this some form of open-existential component?
+  bool isOpenExistential() const {
+    return getKind() == OpenOpaqueExistentialKind ||
+           getKind() == OpenNonOpaqueExistentialKind;
+  }
+
   /// Return the appropriate access kind to use when producing the
   /// base value.
   virtual AccessKind getBaseAccessKind(SILGenFunction &SGF,
@@ -234,7 +241,7 @@ class LogicalPathComponent : public PathComponent {
   ///
   /// \param base - always an address, but possibly an r-value
   virtual void set(SILGenFunction &SGF, SILLocation loc,
-                   RValue &&value, ManagedValue base) && = 0;
+                   ArgumentSource &&value, ManagedValue base) && = 0;
 
   /// Get the property.
   ///
@@ -304,7 +311,7 @@ class TranslationPathComponent : public LogicalPathComponent {
              ManagedValue base, SGFContext c) && override;
 
   void set(SILGenFunction &SGF, SILLocation loc,
-           RValue &&value, ManagedValue base) && override;
+           ArgumentSource &&value, ManagedValue base) && override;
 
   /// Transform from the original pattern.
   virtual RValue translate(SILGenFunction &SGF, SILLocation loc,
@@ -385,6 +392,13 @@ class LValue {
     assert(isLastComponentTranslation());
     Path.pop_back();
   }
+
+  /// Assert that the given component is the last component in the
+  /// l-value, drop it.
+  void dropLastComponent(PathComponent &component) & {
+    assert(&component == Path.back().get());
+    Path.pop_back();
+  }
 
   /// Add a new component at the end of the access path of this lvalue.
   template <class T, class... As>

lib/SILGen/ManagedValue.cpp

@@ -126,6 +126,12 @@ void ManagedValue::assignInto(SILGenFunction &SGF, SILLocation loc,
                         IsNotInitialization);
 }
 
+void ManagedValue::forwardInto(SILGenFunction &SGF, SILLocation loc,
+                               Initialization *dest) {
+  dest->copyOrInitValueInto(SGF, loc, *this, /*isInit*/ true);
+  dest->finishInitialization(SGF);
+}
+
 ManagedValue ManagedValue::borrow(SILGenFunction &SGF, SILLocation loc) const {
   assert(getValue() && "cannot borrow an invalid or in-context value");
   if (isLValue())

lib/SILGen/ManagedValue.h

@@ -31,6 +31,7 @@ enum class CastConsumptionKind : unsigned char;
 
 namespace Lowering {
 
+class Initialization;
 class SILGenFunction;
 
 /// ManagedValue - represents a singular SIL value and an optional cleanup.
@@ -287,6 +288,13 @@ class ManagedValue {
   /// \param loc - the AST location to associate with emitted instructions.
   /// \param address - the address to assign to.
   void forwardInto(SILGenFunction &SGF, SILLocation loc, SILValue address);
+
+  /// Forward this value into the given initialization.
+  ///
+  /// \param SGF - The SILGenFunction.
+  /// \param loc - the AST location to associate with emitted instructions.
+  /// \param dest - the destination to forward into
+  void forwardInto(SILGenFunction &SGF, SILLocation loc, Initialization *dest);
 
   /// Assign this value into memory, destroying the existing
   /// value at the destination address.

lib/SILGen/RValue.h

@@ -227,11 +227,35 @@ class RValue {
 
   /// Rewrite the type of this r-value.
   void rewriteType(CanType newType) & {
+#ifndef NDEBUG
+    static const auto areSimilarTypes = [](CanType l, CanType r) {
+      if (l == r) return true;
+
+      // Allow function types to disagree about 'noescape'.
+      if (auto lf = dyn_cast<FunctionType>(l)) {
+        if (auto rf = dyn_cast<FunctionType>(r)) {
+          return lf.getInput() == rf.getInput()
+              && lf.getResult() == rf.getResult()
+              && lf->getExtInfo().withNoEscape(false) ==
+                 lf->getExtInfo().withNoEscape(false);
+        }
+      }
+      return false;
+    };
+
+    static const auto isSingleElementTuple = [](CanType type, CanType eltType) {
+      if (auto tupleType = dyn_cast<TupleType>(type)) {
+        return tupleType->getNumElements() == 1 &&
+               areSimilarTypes(tupleType.getElementType(0), eltType);
+      }
+      return false;
+    };
+
     // We only allow a very modest set of changes to a type.
-    assert(newType == type ||
-           (isa<TupleType>(newType) &&
-            cast<TupleType>(newType)->getNumElements() == 1 &&
-            cast<TupleType>(newType).getElementType(0) == type));
+    assert(areSimilarTypes(newType, type) ||
+           isSingleElementTuple(newType, type) ||
+           isSingleElementTuple(type, newType));
+#endif
     type = newType;
   }
 

lib/SILGen/SGFContext.h

@@ -158,6 +158,10 @@ class SGFContext {
   }
 };
 
+using ValueProducerRef =
+  llvm::function_ref<ManagedValue(SILGenFunction &gen, SILLocation loc,
+                                  SGFContext context)>;
+
 } // end namespace Lowering
 } // end namespace swift
 

lib/SILGen/SILGenApply.cpp

@@ -5164,7 +5164,8 @@ void SILGenFunction::emitSetAccessor(SILLocation loc, SILDeclRef set,
                                      SubstitutionList substitutions,
                                      ArgumentSource &&selfValue,
                                      bool isSuper, bool isDirectUse,
-                                     RValue &&subscripts, RValue &&setValue) {
+                                     RValue &&subscripts,
+                                     ArgumentSource &&setValue) {
   // Scope any further writeback just within this operation.
   FormalEvaluationScope writebackScope(*this);
 
@@ -5184,16 +5185,37 @@ void SILGenFunction::emitSetAccessor(SILLocation loc, SILDeclRef set,
   // (value)  or (value, indices)
   if (!subscripts.isNull()) {
     // If we have a value and index list, create a new rvalue to represent the
-    // both of them together.  The value goes first.
-    SmallVector<ManagedValue, 4> Elts;
-    std::move(setValue).getAll(Elts);
-    std::move(subscripts).getAll(Elts);
-    setValue = RValue::withPreExplodedElements(Elts, accessType.getInput());
+    // both of them together.
+    auto inputTupleType = cast<TupleType>(accessType.getInput());
+
+    SmallVector<ArgumentSource, 4> eltSources;
+
+    // The value comes first.
+    eltSources.push_back(std::move(setValue));
+
+    // The indices come after.  Whether they are expanded or not depends on
+    // whether they were written as separate parameters, which should be
+    // reflected in the params list.
+    // TODO: we should really take an array of RValues.
+    auto params = accessType.getParams();
+    if (params.size() != 2) {
+      auto subscriptsTupleType = cast<TupleType>(subscripts.getType());
+      assert(inputTupleType->getNumElements()
+              == 1 + subscriptsTupleType->getNumElements());
+      SmallVector<RValue, 8> eltRVs;
+      std::move(subscripts).extractElements(eltRVs);
+      for (auto &elt : eltRVs)
+        eltSources.emplace_back(loc, std::move(elt));
+    } else {
+      subscripts.rewriteType(params[1].getType());
+      eltSources.emplace_back(loc, std::move(subscripts));
+    }
+
+    setValue = ArgumentSource(loc, inputTupleType, eltSources);
   } else {
     setValue.rewriteType(accessType.getInput());
   }
-  emission.addCallSite(loc, ArgumentSource(loc, std::move(setValue)),
-                       accessType);
+  emission.addCallSite(loc, std::move(setValue), accessType);
   // ()
   emission.apply();
 }