SIL: Only lower nominal types marked with @_addressableForDependencies as such.

I accidentally typoed the RecursiveProperties constructor so that every type
was getting treated as addressable-for-dependencies. Oops.

Author: jckarter

include/swift/SIL/TypeLowering.h

@@ -222,7 +222,7 @@ class TypeLowering {
             IsNotTypeExpansionSensitive,
         HasRawPointer_t hasRawPointer = DoesNotHaveRawPointer,
         IsLexical_t isLexical = IsNotLexical, HasPack_t hasPack = HasNoPack,
-        IsAddressableForDependencies_t isAFD = IsAddressableForDependencies)
+        IsAddressableForDependencies_t isAFD = IsNotAddressableForDependencies)
         : Flags((isTrivial ? 0U : NonTrivialFlag) |
                 (isFixedABI ? 0U : NonFixedABIFlag) |
                 (isAddressOnly ? AddressOnlyFlag : 0U) |

lib/SIL/IR/TypeLowering.cpp

@@ -2510,6 +2510,7 @@ namespace {
       }
 
       if (D->isCxxNonTrivial()) {
+        properties.setAddressableForDependencies();
         properties.setAddressOnly();
         properties.setNonTrivial();
         properties.setLexical(IsLexical);
@@ -2550,6 +2551,10 @@ namespace {
         properties.setLexical(IsLexical);
         return handleAddressOnly(structType, properties);
       }
+      
+      if (D->getAttrs().hasAttribute<AddressableForDependenciesAttr>()) {
+        properties.setAddressableForDependencies();
+      }
 
       auto subMap = structType->getContextSubstitutionMap();
 
@@ -2620,6 +2625,10 @@ namespace {
       if (handleResilience(enumType, D, properties))
         return handleAddressOnly(enumType, properties);
 
+      if (D->getAttrs().hasAttribute<AddressableForDependenciesAttr>()) {
+        properties.setAddressableForDependencies();
+      }
+
       // [is_or_contains_pack_unsubstituted] Visit the elements of the
       // unsubstituted type to find pack types which would be substituted away.
       for (auto elt : D->getAllElements()) {

test/SILOptimizer/addressable_dependencies.swift

@@ -6,6 +6,27 @@
 
 import Builtin
 
+struct NodeRef: ~Escapable {
+    private var parent: UnsafePointer<Node>
+
+    // CHECK-LABEL: sil {{.*}}@${{.*}}7NodeRefV4node{{.*}}fC :
+    // CHECK-SAME:    (@in_guaranteed Node,
+    @lifetime(borrow node)
+    init(node: borrowing Node) {
+        // CHECK: bb0(%0 : @noImplicitCopy $*Node,
+        // CHECK:   [[RAW_PTR:%.*]] = address_to_pointer {{.*}}%0
+        // CHECK:   struct $UnsafePointer<Node> ([[RAW_PTR]])
+        self.parent = UnsafePointer(Builtin.addressOfBorrow(node))
+    }
+
+    // CHECK-LABEL: sil {{.*}}@${{.*}}7NodeRefV9allocated{{.*}}fC :
+    // CHECK-SAME:    (@guaranteed AllocatedNode,
+    @lifetime(borrow allocated)
+    init(allocated: borrowing AllocatedNode) {
+        self.parent = allocated.node
+    }
+}
+
 @_addressableForDependencies
 struct Node {
     var id: String
@@ -23,16 +44,17 @@ struct Node {
     }
 }
 
-struct NodeRef: ~Escapable {
-    private var parent: UnsafePointer<Node>
+// not addressable for dependencies
+struct AllocatedNode: ~Copyable {
+    fileprivate var node: UnsafePointer<Node>
 
-    // CHECK-LABEL: sil {{.*}}@${{.*}}7NodeRefV4node{{.*}}fC :
-    // CHECK-SAME:    (@in_guaranteed Node,
-    @lifetime(borrow node)
-    init(node: borrowing Node) {
-        // CHECK: bb0(%0 : @noImplicitCopy $*Node,
-        // CHECK:   [[RAW_PTR:%.*]] = address_to_pointer {{.*}}%0
-        // CHECK:   struct $UnsafePointer<Node> ([[RAW_PTR]])
-        self.parent = UnsafePointer(Builtin.addressOfBorrow(node))
+    var ref: NodeRef {
+      // CHECK-LABEL: sil {{.*}}@${{.*}}13AllocatedNodeV3ref{{.*}}Vvg :
+      // CHECK-SAME:    (@guaranteed AllocatedNode) ->
+      @lifetime(borrow self)
+      borrowing get {
+        return NodeRef(allocated: self)
+      }
     }
 }
+