[AutoDiff] Change TangentVector memberwise initializer access level.

Change the access level of synthesized `TangentVector` struct memberwise
initializers to match the access level of the `TangentVector` struct itself.

Previously, memberwise initializers of public synthesized `TangentVector`
structs were internal. Now, they are public, 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,32 @@ 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:
+  // - The access level of the nominal type declaration itself.
+  // - The access level of each memberwise-initialized property in the nominal
+  //   type declaration.
+  auto accessLevel = std::min(AccessLevel::Public, nominal->getFormalAccess());
+  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,18 @@ 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:
+// - The access level of the nominal type declaration itself.
+// - 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:     internal init()
+// CHECK:   }
+// CHECK: }
+
+// CHECK-LABEL: private struct PrivateStruct : Differentiable {
+// CHECK:   internal init()
+// CHECK:   fileprivate struct TangentVector : Differentiable, AdditiveArithmetic, PointwiseMultiplicative, ElementaryFunctions {
+// CHECK:     fileprivate 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:     internal init()
+// CHECK:   }
+// CHECK: }
+
+// CHECK-LABEL: private class PrivateClass : Differentiable {
+// CHECK:   internal init()
+// CHECK:   fileprivate struct TangentVector : Differentiable, AdditiveArithmetic, PointwiseMultiplicative, ElementaryFunctions {
+// CHECK:     fileprivate 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}}