model the ABISafeConversionComponent as a translation component, rather than physical

Also renaming it to be UncheckedConversionComponent since it's a better name.

As a physical component, we'd run into problems in assignment statements.
The problem was that if we had something like:

```
SomeOtherComponent          // first component
GetterSetterComponent
ABISafeConversionComponent  // last component
```

When emitting the assignment, we always drill down through all but
the last component by calling `project()` on each one. Then on the last
component, we'd do the actual setting operation. But GetterSetterComponent
cannot be projected when the access is for writing.

So, to work around this I decided to model it as a TranslationComponent, because
those are specifically designed to be handled during an assignment by popping those
off the end of the component sequence, untranslating the value we're about to assign
as we go, until we hit the GetterSetterComponent.

By "untranslating" we're effectively putting Sendable back onto the set's argument
prior to calling set, because the underlying property's type still has `@Sendable`
on it (e.g., it's accessors still have that on its argument type). When
"translating" we're effectively taking Sendable off after reading it.

I think actually works really well and makes much more sense now.

resolves rdar://99619834

Author: kavon

lib/SILGen/LValue.h

@@ -105,7 +105,6 @@ class PathComponent {
     CoroutineAccessorKind,      // coroutine accessor
     ValueKind,                  // random base pointer as an lvalue
     PhysicalKeyPathApplicationKind, // applying a key path
-    ABISafeConversionKind,        // unchecked_addr_cast
 
     // Logical LValue kinds
     GetterSetterKind,           // property or subscript getter/setter
@@ -118,6 +117,7 @@ class PathComponent {
     // Translation LValue kinds (a subtype of logical)
     OrigToSubstKind,            // generic type substitution
     SubstToOrigKind,            // generic type substitution
+    UncheckedConversionKind,    // unchecked_X_cast
 
     FirstLogicalKind = GetterSetterKind,
     FirstTranslationKind = OrigToSubstKind,

lib/SILGen/SILGenBuilder.cpp

@@ -620,7 +620,8 @@ ManagedValue SILGenBuilder::createUncheckedBitCast(SILLocation loc,
   // updated.
   assert((isa<UncheckedTrivialBitCastInst>(cast) ||
           isa<UncheckedRefCastInst>(cast) ||
-          isa<UncheckedBitwiseCastInst>(cast)) &&
+          isa<UncheckedBitwiseCastInst>(cast) ||
+          isa<ConvertFunctionInst>(cast)) &&
          "SILGenBuilder is out of sync with SILBuilder.");
 
   // If we have a trivial inst, just return early.

lib/SILGen/SILGenLValue.cpp

@@ -2204,26 +2204,82 @@ namespace {
     }
   };
 
-  /// A physical component which performs an unchecked_addr_cast
-  class ABISafeConversionComponent final : public PhysicalPathComponent {
+  /// A translation component that performs \c unchecked_*_cast 's as-needed.
+  class UncheckedConversionComponent final : public TranslationPathComponent {
+  private:
+    Type OrigType;
+
+    /// \returns the type this component is trying to convert \b to
+    CanType getTranslatedType() const {
+      return getTypeData().SubstFormalType->getCanonicalType();
+    }
+
+    /// \returns the type this component is trying to convert \b from
+    CanType getUntranslatedType() const {
+      return OrigType->getRValueType()->getCanonicalType();
+    }
+
+    /// perform a conversion of ManagedValue -> ManagedValue
+    ManagedValue doUncheckedConversion(SILGenFunction &SGF, SILLocation loc,
+                                       ManagedValue val, CanType toType) {
+      auto toTy = SGF.getLoweredType(toType);
+      auto fromTy = val.getType();
+
+      if (fromTy == toTy)
+        return val; // nothing to do.
+
+      // otherwise emit the right kind of cast based on whether it's an address.
+      assert(fromTy.isAddress() == toTy.isAddress());
+
+      if (toTy.isAddress())
+        return SGF.B.createUncheckedAddrCast(loc, val, toTy);
+
+      return SGF.B.createUncheckedBitCast(loc, val, toTy);
+    }
+
+    /// perform a conversion of RValue -> RValue
+    RValue doUncheckedConversion(SILGenFunction &SGF, SILLocation loc,
+                                 RValue &&rv, CanType toType) {
+      auto val = std::move(rv).getAsSingleValue(SGF, loc);
+      val = doUncheckedConversion(SGF, loc, val, toType);
+      return RValue(SGF, loc, toType, val);
+    }
+
   public:
-    ABISafeConversionComponent(LValueTypeData typeData)
-      : PhysicalPathComponent(typeData, ABISafeConversionKind,
-                              /*actorIsolation=*/None) {}
+    /// \param OrigType is the type we are converting \b from
+    /// \param typeData will contain the type we are converting \b to
+    UncheckedConversionComponent(LValueTypeData typeData, Type OrigType)
+      : TranslationPathComponent(typeData, UncheckedConversionKind),
+      OrigType(OrigType) {}
 
-    ManagedValue project(SILGenFunction &SGF, SILLocation loc,
-                         ManagedValue base) && override {
-      auto toType = SGF.getLoweredType(getTypeData().SubstFormalType)
-                       .getAddressType();
+    bool isLoadingPure() const override { return true; }
 
-      if (base.getType() == toType)
-        return base; // nothing to do
+    /// Used during write operations to convert the value prior to writing to
+    /// the base.
+    RValue untranslate(SILGenFunction &SGF, SILLocation loc,
+                       RValue &&rv, SGFContext c) && override {
+      return doUncheckedConversion(SGF, loc, std::move(rv),
+                getUntranslatedType());
+    }
 
-      return SGF.B.createUncheckedAddrCast(loc, base, toType);
+    /// Used during read operations to convert the value after reading the base.
+    RValue translate(SILGenFunction &SGF, SILLocation loc,
+                     RValue &&rv, SGFContext c) && override {
+      return doUncheckedConversion(SGF, loc, std::move(rv),
+                getTranslatedType());
+    }
+
+    std::unique_ptr<LogicalPathComponent>
+    clone(SILGenFunction &SGF, SILLocation loc) const override {
+      return std::make_unique<UncheckedConversionComponent>(getTypeData(),
+                                                            OrigType);
     }
 
     void dump(raw_ostream &OS, unsigned indent) const override {
-      OS.indent(indent) << "ABISafeConversionComponent\n";
+      OS.indent(indent) << "UncheckedConversionComponent"
+                        << "\n\tfromType: " << getUntranslatedType()
+                        << "\n\ttoType: " << getTranslatedType()
+                        << "\n";
     }
   };
 } // end anonymous namespace
@@ -3741,7 +3797,9 @@ LValue SILGenLValue::visitABISafeConversionExpr(ABISafeConversionExpr *e,
   LValue lval = visitRec(e->getSubExpr(), accessKind, options);
   auto typeData = getValueTypeData(SGF, accessKind, e);
 
-  lval.add<ABISafeConversionComponent>(typeData);
+  auto OrigType = e->getSubExpr()->getType();
+
+  lval.add<UncheckedConversionComponent>(typeData, OrigType);
 
   return lval;
 }