[move-only] Change type lowering to ensure that we use {retain,release}_value instead of strong_{retain,release} for move only enum/structs

This ensures that when we hit IRGen, if we have a type with trivial contents, we
emit nothing and if we have a type with non-trivial contents, we just emit
recursive retain/release as appropriate.

This is the last bug holding up the buffer view prototype from Guilliume.

Author: gottesmm

lib/SIL/IR/TypeLowering.cpp

@@ -1459,6 +1459,110 @@ namespace {
     }
   };
 
+  /// A lowering for loadable but non-trivial struct types.
+  class MoveOnlyLoadableStructTypeLowering final
+      : public LoadableAggTypeLowering<MoveOnlyLoadableStructTypeLowering,
+                                       VarDecl *> {
+    using Super =
+        LoadableAggTypeLowering<MoveOnlyLoadableStructTypeLowering, VarDecl *>;
+
+  public:
+    MoveOnlyLoadableStructTypeLowering(CanType type,
+                                       RecursiveProperties properties,
+                                       TypeExpansionContext forExpansion)
+        : LoadableAggTypeLowering(type, properties, forExpansion) {}
+
+    SILValue emitRValueProject(SILBuilder &B, SILLocation loc,
+                               SILValue structValue, VarDecl *field,
+                               const TypeLowering &fieldLowering) const {
+      return B.createStructExtract(loc, structValue, field,
+                                   fieldLowering.getLoweredType());
+    }
+
+    void destructureAggregate(
+        SILBuilder &B, SILLocation loc, SILValue aggValue, bool skipTrivial,
+        function_ref<void(unsigned childIndex, SILValue childValue,
+                          const TypeLowering &childLowering)>
+            visitor) const {
+      if (!B.hasOwnership())
+        return Super::destructureAggregate(B, loc, aggValue, skipTrivial,
+                                           visitor);
+
+      auto *dsi = B.createDestructureStruct(loc, aggValue);
+      for (auto pair : llvm::enumerate(dsi->getResults())) {
+        SILValue childValue = pair.value();
+        auto &childLowering =
+            B.getFunction().getTypeLowering(childValue->getType());
+        if (skipTrivial && childLowering.isTrivial())
+          continue;
+        visitor(pair.index(), childValue, childLowering);
+      }
+    }
+
+    SILValue rebuildAggregate(SILBuilder &B, SILLocation loc,
+                              ArrayRef<SILValue> values) const override {
+      return B.createStruct(loc, getLoweredType(), values);
+    }
+
+  private:
+    void lowerChildren(TypeConverter &TC,
+                       SmallVectorImpl<Child> &children) const override {
+      auto silTy = getLoweredType();
+      auto structDecl = silTy.getStructOrBoundGenericStruct();
+      assert(structDecl);
+
+      for (auto prop : structDecl->getStoredProperties()) {
+        SILType propTy = silTy.getFieldType(prop, TC, getExpansionContext());
+        auto &propTL = TC.getTypeLowering(propTy, getExpansionContext());
+        children.push_back(Child{prop, propTL});
+      }
+    }
+  };
+
+  /// A lowering for loadable but non-trivial enum types.
+  class MoveOnlyLoadableEnumTypeLowering final
+      : public NonTrivialLoadableTypeLowering {
+  public:
+    MoveOnlyLoadableEnumTypeLowering(CanType type,
+                                     RecursiveProperties properties,
+                                     TypeExpansionContext forExpansion)
+        : NonTrivialLoadableTypeLowering(SILType::getPrimitiveObjectType(type),
+                                         properties, IsNotReferenceCounted,
+                                         forExpansion) {}
+
+    SILValue emitCopyValue(SILBuilder &B, SILLocation loc,
+                           SILValue value) const override {
+      if (B.getFunction().hasOwnership())
+        return B.createCopyValue(loc, value);
+      B.createRetainValue(loc, value, B.getDefaultAtomicity());
+      return value;
+    }
+
+    SILValue emitLoweredCopyValue(SILBuilder &B, SILLocation loc,
+                                  SILValue value,
+                                  TypeExpansionKind style) const override {
+      if (B.getFunction().hasOwnership())
+        return B.createCopyValue(loc, value);
+      B.createRetainValue(loc, value, B.getDefaultAtomicity());
+      return value;
+    }
+
+    void emitDestroyValue(SILBuilder &B, SILLocation loc,
+                          SILValue value) const override {
+      if (B.getFunction().hasOwnership()) {
+        B.createDestroyValue(loc, value);
+        return;
+      }
+      B.createReleaseValue(loc, value, B.getDefaultAtomicity());
+    }
+
+    void emitLoweredDestroyValue(SILBuilder &B, SILLocation loc, SILValue value,
+                                 TypeExpansionKind style) const override {
+      // Enums, we never want to expand.
+      return emitDestroyValue(B, loc, value);
+    }
+  };
+
   /// A type lowering for `@differentiable(_linear)` function types.
   class LinearDifferentiableSILFunctionTypeLowering final
       : public LoadableAggTypeLowering<
@@ -2146,7 +2250,8 @@ namespace {
         properties.setNonTrivial();
         if (properties.isAddressOnly())
           return handleMoveOnlyAddressOnly(structType, properties);
-        return handleMoveOnlyReference(structType, properties);
+        return new (TC) MoveOnlyLoadableStructTypeLowering(
+            structType, properties, Expansion);
       }
 
       return handleAggregateByProperties<LoadableStructTypeLowering>(structType,
@@ -2223,7 +2328,8 @@ namespace {
         properties.setNonTrivial();
         if (properties.isAddressOnly())
           return handleMoveOnlyAddressOnly(enumType, properties);
-        return handleMoveOnlyReference(enumType, properties);
+        return new (TC)
+            MoveOnlyLoadableEnumTypeLowering(enumType, properties, Expansion);
       }
 
       return handleAggregateByProperties<LoadableEnumTypeLowering>(enumType,

test/Interpreter/moveonly_bufferview.swift

@@ -8,14 +8,14 @@
 
 @_moveOnly
 public struct BufferView<T> {
-    var ptr: UnsafeMutableBufferPointer<T>
+    var ptr: UnsafeBufferPointer<T>
 
     deinit {}
 }
 
 extension BufferView : Sequence {
-    public typealias Iterator = UnsafeMutableBufferPointer<T>.Iterator
-    public typealias Element = UnsafeMutableBufferPointer<T>.Element
+    public typealias Iterator = UnsafeBufferPointer<T>.Iterator
+    public typealias Element = UnsafeBufferPointer<T>.Element
 
     public func makeIterator() -> Self.Iterator {
         return ptr.makeIterator()
@@ -24,7 +24,7 @@ extension BufferView : Sequence {
 
 extension Array {
     public mutating func withBufferView<U>(_ f: (BufferView<Element>) -> U) -> U {
-        return withUnsafeMutableBufferPointer {
+        return withUnsafeBufferPointer {
             return f(BufferView(ptr: $0))
         }
     }
@@ -42,8 +42,26 @@ func testBufferView(_ x: __owned [Int]) {
     }
 }
 
+@inline(never)
+func getBool() -> Bool { return true }
+
+func testConditionalBufferView(_ x: __owned [Int]) {
+    (_move x).withUnsafeBufferPointer {
+        let y = BufferView(ptr: $0)
+        // CHECK: 4
+        // CHECK: 5
+        // CHECK: 6
+        if getBool() {
+            for z in y {
+                print(z)
+            }
+        }
+    }
+}
+
 func main() {
     testBufferView([1,2,3])
+    testConditionalBufferView([4,5,6])
 }
 
 main()