[AutoDiff] Change TangentVector memberwise initializer access level. (#28908)

Previously, memberwise initializers of synthesized `TangentVector` structs were
internal by default. Now, they are public by default, improving usability.

Note that public synthesized memberwise initializers have no precedent in
Swift. For normal public structs, it's possible to manually define a public
memberwise initializer, skipping synthesis. However, since `TangentVector`
structs are always synthesized with a memberwise initializer, manually defining
a public memberwise initializer in an extension leads to a redeclaration error.

A broader discussion on memberwise initializer access levels may be
worthwhile.

Resolves TF-1077.

Author: dan-zheng

lib/Sema/CodeSynthesis.cpp

@@ -278,6 +278,33 @@ ConstructorDecl *swift::createMemberwiseImplicitConstructor(
                                    ctx);
 }
 
+// SWIFT_ENABLE_TENSORFLOW
+ConstructorDecl *swift::getOrCreateEffectiveMemberwiseInitializer(
+    ASTContext &ctx, NominalTypeDecl *nominal) {
+  // Compute the access level for the memberwise initializer: the minimum of:
+  // - Public, by default. This enables public nominal types to have public
+  //   memberwise initializers.
+  // - The access level of each memberwise-initialized property in the nominal
+  //   type declaration.
+  auto accessLevel = AccessLevel::Public;
+  for (auto *member : nominal->getMembers()) {
+    auto var = dyn_cast<VarDecl>(member);
+    if (!var ||
+        !var->isMemberwiseInitialized(/*preferDeclaredProperties=*/true))
+      continue;
+    accessLevel = std::min(accessLevel, var->getFormalAccess());
+  }
+  if (auto *initDecl = nominal->getEffectiveMemberwiseInitializer()) {
+    initDecl->overwriteAccess(accessLevel);
+    return initDecl;
+  }
+  auto *initDecl = createMemberwiseImplicitConstructor(ctx, nominal);
+  initDecl->overwriteAccess(accessLevel);
+  nominal->addMember(initDecl);
+  return initDecl;
+}
+// SWIFT_ENABLE_TENSORFLOW END
+
 /// Create a stub body that emits a fatal error message.
 static std::pair<BraceStmt *, bool>
 synthesizeStubBody(AbstractFunctionDecl *fn, void *) {

lib/Sema/CodeSynthesis.h

@@ -65,6 +65,23 @@ Expr *buildArgumentForwardingExpr(ArrayRef<ParamDecl*> params,
 
 ConstructorDecl *createMemberwiseImplicitConstructor(ASTContext &ctx,
                                                      NominalTypeDecl *decl);
+
+// SWIFT_ENABLE_TENSORFLOW
+// Get the effective memberwise initializer of the given nominal type, or create
+// it if it does not exist.
+// Sets the access level of the memberwise initializer to the minimum of:
+// - Public, by default. This enables public nominal types to have public
+//   memberwise initializers.
+//   - NOTE(TF-1077): The `public` default is important for `TangentVector`
+//     structs synthesized during `Differentiable` derived conformances.
+//     Manually extending `TangentVector` structs to define a public
+//     memberwise initializer causes a redeclaration error.
+// - The access level of each memberwise-initialized property in the nominal
+//   type declaration.
+ConstructorDecl *getOrCreateEffectiveMemberwiseInitializer(
+    ASTContext &ctx, NominalTypeDecl *nominal);
+// SWIFT_ENABLE_TENSORFLOW END
+
 } // end namespace swift
 
 #endif

lib/Sema/DerivedConformanceElementaryFunctions.cpp

@@ -100,17 +100,6 @@ static ValueDecl *getElementaryFunctionRequirement(
   }
 }
 
-// Get the effective memberwise initializer of the given nominal type, or create
-// it if it does not exist.
-static ConstructorDecl *getOrCreateEffectiveMemberwiseInitializer(
-    ASTContext &ctx, NominalTypeDecl *nominal) {
-  if (auto *initDecl = nominal->getEffectiveMemberwiseInitializer())
-    return initDecl;
-  auto *initDecl = createMemberwiseImplicitConstructor(ctx, nominal);
-  nominal->addMember(initDecl);
-  return initDecl;
-}
-
 bool DerivedConformance::canDeriveElementaryFunctions(NominalTypeDecl *nominal,
                                                       DeclContext *DC) {
   // Nominal type must be a struct. (Zero stored properties is okay.)

lib/Sema/DerivedConformanceRingMathProtocols.cpp

@@ -75,18 +75,6 @@ static ValueDecl *getProtocolRequirement(ProtocolDecl *proto, Identifier name) {
   return lookup.front();
 }
 
-// Get the effective memberwise initializer of the given nominal type, or create
-// it if it does not exist.
-static ConstructorDecl *getOrCreateEffectiveMemberwiseInitializer(
-    ASTContext &ctx, NominalTypeDecl *nominal) {
-  if (auto *initDecl = nominal->getEffectiveMemberwiseInitializer())
-    return initDecl;
-  auto *initDecl = createMemberwiseImplicitConstructor(
-      ctx, nominal);
-  nominal->addMember(initDecl);
-  return initDecl;
-}
-
 // Return true if given nominal type has a `let` stored with an initial value.
 // TODO: Move function to shared place for use with other derived conformances.
 static bool hasLetStoredPropertyWithInitialValue(NominalTypeDecl *nominal) {

test/Sema/differentiable_access_level.swift

@@ -0,0 +1,56 @@
+// SWIFT_ENABLE_TENSORFLOW
+// RUN: %target-swift-frontend -print-ast %s | %FileCheck %s
+
+// Test `Differentiable` derived conformances.
+// Verify access levels of synthesized `TangentVector` types and their memberwise initializers.
+// `TangentVector` memberwise initializer access level should match `TangentVector` access level.
+
+public struct PublicStruct: Differentiable {}
+internal struct InternalStruct: Differentiable {}
+private struct PrivateStruct: Differentiable {}
+
+// CHECK-LABEL: public struct PublicStruct : Differentiable {
+// CHECK:   internal init()
+// CHECK:   public struct TangentVector : Differentiable, AdditiveArithmetic, PointwiseMultiplicative, ElementaryFunctions {
+// CHECK:     public init()
+// CHECK:   }
+// CHECK: }
+
+// CHECK-LABEL: internal struct InternalStruct : Differentiable {
+// CHECK:   internal init()
+// CHECK:   internal struct TangentVector : Differentiable, AdditiveArithmetic, PointwiseMultiplicative, ElementaryFunctions {
+// CHECK:     public init()
+// CHECK:   }
+// CHECK: }
+
+// CHECK-LABEL: private struct PrivateStruct : Differentiable {
+// CHECK:   internal init()
+// CHECK:   fileprivate struct TangentVector : Differentiable, AdditiveArithmetic, PointwiseMultiplicative, ElementaryFunctions {
+// CHECK:     public init()
+// CHECK:   }
+// CHECK: }
+
+public class PublicClass: Differentiable {}
+internal class InternalClass: Differentiable {}
+private class PrivateClass: Differentiable {}
+
+// CHECK-LABEL: public class PublicClass : Differentiable {
+// CHECK:   internal init()
+// CHECK:   public struct TangentVector : Differentiable, AdditiveArithmetic, PointwiseMultiplicative, ElementaryFunctions {
+// CHECK:     public init()
+// CHECK:   }
+// CHECK: }
+
+// CHECK-LABEL: internal class InternalClass : Differentiable {
+// CHECK:   internal init()
+// CHECK:   internal struct TangentVector : Differentiable, AdditiveArithmetic, PointwiseMultiplicative, ElementaryFunctions {
+// CHECK:     public init()
+// CHECK:   }
+// CHECK: }
+
+// CHECK-LABEL: private class PrivateClass : Differentiable {
+// CHECK:   internal init()
+// CHECK:   fileprivate struct TangentVector : Differentiable, AdditiveArithmetic, PointwiseMultiplicative, ElementaryFunctions {
+// CHECK:     public init()
+// CHECK:   }
+// CHECK: }

test/Sema/struct_differentiable.swift

@@ -414,7 +414,7 @@ extension NoMemberwiseInitializerExtended: Differentiable
 extension NoMemberwiseInitializerExtended: EuclideanDifferentiable
   where T : Differentiable & AdditiveArithmetic {}
 
-// Test derived conformances in disallowed contexts.
+// Verify that cross-file derived conformances are disallowed.
 
 // expected-error @+2 {{type 'OtherFileNonconforming' does not conform to protocol 'Differentiable'}}
 // expected-error @+1 {{implementation of 'Differentiable' cannot be automatically synthesized in an extension in a different file to the type}}