[AutoDiff] [stdlib] Derive conformances for 'EuclideanDifferentiable'.

* Add derived conformances for the `EuclideanDifferentiable` protocol introduced in #26287 when a conforming type satisfies `Differentiable` conformance synthesis requirements.

    ```swift
    struct Foo<T>: EuclideanDifferentiable where T.TangentVector == T {
      var x: T
      var y: T
      @noDerivative var z: Bool
      // The compiler synthesizes the following `EuclideanDifferentiable` requirement:
      //   var vectorView: TangentVector {
      //     return TangentVector(x: x, y: y)
      //   }
    }
    ```

* Remove `vectorView`'s setter. This should not have been added to the protocol, for the same reason as [TF-208](https://bugs.swift.org/browse/TF-208). A projection (`vectorView`) of a subset of properties should reflect these properties joint mutability, which is impossible to express at the moment.

Resolves [TF-777](https://bugs.swift.org/browse/TF-777).

Author: rxwei

include/swift/AST/DiagnosticsSema.def

@@ -2576,6 +2576,8 @@ ERROR(broken_vector_protocol_requirement,none,
       "VectorProtocol protocol is broken: unexpected requirement", ())
 ERROR(broken_differentiable_requirement,none,
       "Differentiable protocol is broken: unexpected requirement", ())
+ERROR(broken_euclidean_differentiable_requirement,none,
+      "EuclideanDifferentiable protocol is broken: unexpected requirement", ())
 ERROR(broken_key_path_iterable_requirement,none,
       "KeyPathIterable protocol is broken: unexpected requirement", ())
 ERROR(broken_tensor_array_protocol_requirement,none,

include/swift/AST/KnownIdentifiers.def

@@ -157,6 +157,7 @@ IDENTIFIER(x)
 // Differentiable
 IDENTIFIER(TangentVector)
 IDENTIFIER(move)
+IDENTIFIER(vectorView)
 
 // Kinds of layout constraints
 IDENTIFIER_WITH_NAME(UnknownLayout, "_UnknownLayout")

include/swift/AST/KnownProtocols.def

@@ -87,6 +87,7 @@ PROTOCOL_(TensorFlowDataTypeCompatible)
 PROTOCOL(TensorProtocol)
 PROTOCOL(VectorProtocol)
 PROTOCOL(Differentiable)
+PROTOCOL(EuclideanDifferentiable)
 
 PROTOCOL_(ObjectiveCBridgeable)
 PROTOCOL_(DestructorSafeContainer)

lib/IRGen/GenMeta.cpp

@@ -4223,6 +4223,7 @@ SpecialProtocol irgen::getSpecialProtocolID(ProtocolDecl *P) {
   case KnownProtocolKind::TensorProtocol:
   case KnownProtocolKind::VectorProtocol:
   case KnownProtocolKind::Differentiable:
+  case KnownProtocolKind::EuclideanDifferentiable:
     return SpecialProtocol::None;
   }
 

lib/Sema/DerivedConformanceDifferentiable.cpp

@@ -196,6 +196,33 @@ bool DerivedConformance::canDeriveDifferentiable(NominalTypeDecl *nominal,
   });
 }
 
+/// Determine if a EuclideanDifferentiable requirement can be derived for a type.
+///
+/// \returns True if the requirement can be derived.
+bool DerivedConformance::canDeriveEuclideanDifferentiable(
+    NominalTypeDecl *nominal, DeclContext *DC) {
+  if (!canDeriveDifferentiable(nominal, DC))
+    return false;
+  auto &C = nominal->getASTContext();
+  auto *lazyResolver = C.getLazyResolver();
+  auto *addArithProto = C.getProtocol(KnownProtocolKind::AdditiveArithmetic);
+  // Return true if all differentiation stored properties conform to
+  // `AdditiveArithmetic` and their `TangentVector` equals themselves.
+  SmallVector<VarDecl *, 16> diffProperties;
+  getStoredPropertiesForDifferentiation(nominal, DC, diffProperties);
+  return llvm::all_of(diffProperties, [&](VarDecl *member) {
+    if (!member->hasInterfaceType())
+      lazyResolver->resolveDeclSignature(member);
+    if (!member->hasInterfaceType())
+      return false;
+    auto varType = DC->mapTypeIntoContext(member->getValueInterfaceType());
+    if (!TypeChecker::conformsToProtocol(varType, addArithProto, DC, None))
+      return false;
+    auto memberAssocType = getTangentVectorType(member, DC);
+    return member->getType()->isEqual(memberAssocType);
+  });
+}
+
 // Synthesize body for a `Differentiable` method requirement.
 static std::pair<BraceStmt *, bool>
 deriveBodyDifferentiable_method(AbstractFunctionDecl *funcDecl,
@@ -343,6 +370,90 @@ static ValueDecl *deriveDifferentiable_move(DerivedConformance &derived) {
       {deriveBodyDifferentiable_move, nullptr});
 }
 
+// Synthesize the `vectorView` property declaration.
+static ValueDecl *deriveEuclideanDifferentiable_vectorView(
+    DerivedConformance &derived) {
+  auto &C = derived.TC.Context;
+  auto *parentDC = derived.getConformanceContext();
+
+  auto *tangentDecl = getTangentVectorStructDecl(parentDC);
+  auto tangentType = tangentDecl->getDeclaredInterfaceType();
+  auto tangentContextualType = parentDC->mapTypeIntoContext(tangentType);
+
+  VarDecl *vectorViewDecl;
+  PatternBindingDecl *pbDecl;
+  std::tie(vectorViewDecl, pbDecl) = derived.declareDerivedProperty(
+      C.Id_vectorView, tangentType, tangentContextualType, /*isStatic*/ false,
+      /*isFinal*/ true);
+
+  struct GetterSynthesizerContext {
+    StructDecl *tangentDecl;
+    Type tangentContextualType;
+  };
+
+  auto getterSynthesizer = [](AbstractFunctionDecl *getterDecl, void *ctx)
+      -> std::pair<BraceStmt *, bool> {
+    auto *context = reinterpret_cast<GetterSynthesizerContext *>(ctx);
+    assert(context && "Invalid context");
+    auto *parentDC = getterDecl->getParent();
+    auto *nominal = parentDC->getSelfNominalTypeDecl();
+    auto &C = nominal->getASTContext();
+    SmallVector<VarDecl *, 8> diffProperties;
+    getStoredPropertiesForDifferentiation(nominal, nominal->getDeclContext(),
+                                          diffProperties);
+
+    // Create a reference to the memberwise initializer: `TangentVector.init`.
+    auto *memberwiseInitDecl =
+        context->tangentDecl->getEffectiveMemberwiseInitializer();
+    assert(memberwiseInitDecl && "Memberwise initializer must exist");
+    // `TangentVector`
+    auto *tangentTypeExpr =
+        TypeExpr::createImplicit(context->tangentContextualType, C);
+    // `TangentVector.init`
+    auto *initDRE = new (C) DeclRefExpr(memberwiseInitDecl, DeclNameLoc(),
+                                        /*Implicit*/ true);
+    initDRE->setFunctionRefKind(FunctionRefKind::SingleApply);
+    auto *initExpr = new (C) ConstructorRefCallExpr(initDRE, tangentTypeExpr);
+    initExpr->setThrows(false);
+    initExpr->setImplicit();
+
+    // Create a call:
+    //   TangentVector.init(
+    //     <property_name_1...>: self.<property_name_1>,
+    //     <property_name_2...>: self.<property_name_2>,
+    //     ...
+    //   )
+    SmallVector<Identifier, 8> argLabels;
+    SmallVector<Expr *, 8> memberRefs;
+    auto *selfDRE = new (C) DeclRefExpr(getterDecl->getImplicitSelfDecl(),
+                                        DeclNameLoc(),
+                                        /*Implicit*/ true);
+    for (auto *member : diffProperties) {
+      argLabels.push_back(member->getName());
+      memberRefs.push_back(
+          new (C) MemberRefExpr(selfDRE, SourceLoc(), member, DeclNameLoc(),
+                                /*Implicit*/ true));
+    }
+    assert(memberRefs.size() == argLabels.size());
+    CallExpr *callExpr =
+        CallExpr::createImplicit(C, initExpr, memberRefs, argLabels);
+
+    // Create a return statement: `return TangentVector.init(...)`.
+    ASTNode retStmt =
+        new (C) ReturnStmt(SourceLoc(), callExpr, /*implicit*/ true);
+    auto *braceStmt = BraceStmt::create(C, SourceLoc(), retStmt, SourceLoc(),
+                                        /*implicit*/ true);
+    return std::make_tuple(braceStmt, false);
+  };
+  auto *getterDecl = derived.addGetterToReadOnlyDerivedProperty(
+      vectorViewDecl, tangentContextualType);
+  getterDecl->setBodySynthesizer(
+      getterSynthesizer, /*context*/ C.AllocateObjectCopy(
+          GetterSynthesizerContext{tangentDecl, tangentContextualType}));
+  derived.addMembersToConformanceContext({vectorViewDecl, pbDecl});
+  return vectorViewDecl;
+}
+
 // Return associated `TangentVector` struct for a nominal type, if it exists.
 // If not, synthesize the struct.
 static StructDecl *
@@ -362,8 +473,7 @@ getOrSynthesizeTangentVectorStruct(DerivedConformance &derived, Identifier id) {
     return structDecl;
   }
 
-  // Otherwise, synthesize a new struct. The struct must conform to
-  // `Differentiable`.
+  // Otherwise, synthesize a new struct.
   auto *diffableProto = C.getProtocol(KnownProtocolKind::Differentiable);
   auto diffableType = TypeLoc::withoutLoc(diffableProto->getDeclaredType());
   auto *addArithProto = C.getProtocol(KnownProtocolKind::AdditiveArithmetic);
@@ -378,9 +488,9 @@ getOrSynthesizeTangentVectorStruct(DerivedConformance &derived, Identifier id) {
   auto *kpIterableProto = C.getProtocol(KnownProtocolKind::KeyPathIterable);
   auto kpIterableType = TypeLoc::withoutLoc(kpIterableProto->getDeclaredType());
 
-  SmallVector<TypeLoc, 4> inherited{diffableType};
-  // `TangentVector` must conform to `AdditiveArithmetic`.
-  inherited.push_back(addArithType);
+  // By definition, `TangentVector` must conform to `EuclideanDifferentiable`
+  // and `AdditiveArithmetic`.
+  SmallVector<TypeLoc, 4> inherited{diffableType, addArithType};
 
   // Cache original members and their associated types for later use.
   SmallVector<VarDecl *, 8> diffProperties;
@@ -756,3 +866,18 @@ Type DerivedConformance::deriveDifferentiable(AssociatedTypeDecl *requirement) {
   TC.diagnose(requirement->getLoc(), diag::broken_differentiable_requirement);
   return nullptr;
 }
+
+/// Derive a EuclideanDifferentiable requirement for a nominal type.
+///
+/// \returns the derived member, which will also be added to the type.
+ValueDecl *DerivedConformance::deriveEuclideanDifferentiable(
+    ValueDecl *requirement) {
+  // Diagnose conformances in disallowed contexts.
+  if (checkAndDiagnoseDisallowedContext(requirement))
+    return nullptr;
+  if (requirement->getFullName() == TC.Context.Id_vectorView)
+    return deriveEuclideanDifferentiable_vectorView(*this);
+  TC.diagnose(requirement->getLoc(),
+              diag::broken_euclidean_differentiable_requirement);
+  return nullptr;
+}

lib/Sema/DerivedConformances.cpp

@@ -94,6 +94,10 @@ bool DerivedConformance::derivesProtocolConformance(DeclContext *DC,
   if (*knownProtocol == KnownProtocolKind::Differentiable)
     return canDeriveDifferentiable(Nominal, DC);
 
+  // SWIFT_ENABLE_TENSORFLOW
+  if (*knownProtocol == KnownProtocolKind::EuclideanDifferentiable)
+    return canDeriveEuclideanDifferentiable(Nominal, DC);
+
   if (auto *enumDecl = dyn_cast<EnumDecl>(Nominal)) {
     switch (*knownProtocol) {
         // The presence of a raw type is an explicit declaration that
@@ -255,6 +259,11 @@ ValueDecl *DerivedConformance::getDerivableRequirement(NominalTypeDecl *nominal,
     if (name.isSimpleName(ctx.Id_zero))
       return getRequirement(KnownProtocolKind::AdditiveArithmetic);
 
+    // SWIFT_ENABLE_TENSORFLOW
+    // EuclideanDifferentiable.vectorView
+    if (name.isSimpleName(ctx.Id_vectorView))
+      return getRequirement(KnownProtocolKind::EuclideanDifferentiable);
+
     // SWIFT_ENABLE_TENSORFLOW
     // PointwiseMultiplicative.one
     if (name.isSimpleName(ctx.Id_one))

lib/Sema/DerivedConformances.h

@@ -292,6 +292,17 @@ class DerivedConformance {
   /// \returns the derived member, which will also be added to the type.
   ValueDecl *deriveDifferentiable(ValueDecl *requirement);
 
+  /// Determine if a Differentiable requirement can be derived for a type.
+  ///
+  /// \returns True if the requirement can be derived.
+  static bool canDeriveEuclideanDifferentiable(NominalTypeDecl *type,
+                                               DeclContext *DC);
+
+  /// Derive a EuclideanDifferentiable requirement for a nominal type.
+  ///
+  /// \returns the derived member, which will also be added to the type.
+  ValueDecl *deriveEuclideanDifferentiable(ValueDecl *requirement);
+
   /// Derive a Differentiable type witness for a nominal type.
   ///
   /// \returns the derived member, which will also be added to the type.

lib/Sema/TypeCheckProtocol.cpp

@@ -5363,6 +5363,10 @@ ValueDecl *TypeChecker::deriveProtocolRequirement(DeclContext *DC,
   case KnownProtocolKind::Differentiable:
     return derived.deriveDifferentiable(Requirement);
 
+  // SWIFT_ENABLE_TENSORFLOW
+  case KnownProtocolKind::EuclideanDifferentiable:
+    return derived.deriveEuclideanDifferentiable(Requirement);
+
   default:
     return nullptr;
   }

stdlib/public/core/AutoDiff.swift

@@ -229,14 +229,12 @@ public extension Differentiable where TangentVector == Self {
 ///   `TangentVector` is equal to its vector space component.
 public protocol EuclideanDifferentiable: Differentiable {
   /// The differentiable vector component of `self`.
-  var vectorView: TangentVector { get set }
+  var vectorView: TangentVector { get }
 }
 
-public extension EuclideanDifferentiable where TangentVector == Self {
-  var vectorView: TangentVector {
-    _read { yield self }
-    _modify { yield &self }
-  }
+public extension EuclideanDifferentiable
+    where TangentVector: EuclideanDifferentiable, TangentVector == Self {
+  var vectorView: TangentVector { _read { yield self } }
 }
 
 /// Returns `x` like an identity function. When used in a context where `x` is

test/AutoDiff/derived_conformances.swift

@@ -30,4 +30,13 @@ DerivedConformanceTests.test("MemberwiseInitializers") {
               HasNoDerivativeConstant.TangentVector.zero)
 }
 
+DerivedConformanceTests.test("EuclideanVectorView") {
+  struct Foo: EuclideanDifferentiable {
+    var x: SIMD4<Float>
+    @noDerivative var y: SIMD4<Int32>
+  }
+  let x = Foo(x: [1, 2, 3, 4], y: .zero)
+  expectEqual(Foo.TangentVector(x: [1, 2, 3, 4]), x.vectorView)
+}
+
 runAllTests()

test/AutoDiff/derived_differentiable.swift

@@ -2,47 +2,51 @@
 // RUN: %target-swift-frontend -emit-silgen %s | %FileCheck %s --check-prefix=CHECK-SILGEN
 // RUN: %target-swift-frontend -emit-sil -verify %s
 
-struct PointwiseMultiplicativeDummy : Differentiable, PointwiseMultiplicative {}
+struct PointwiseMultiplicativeDummy : EuclideanDifferentiable, PointwiseMultiplicative {}
 
-public struct Foo : Differentiable {
+public struct Foo : EuclideanDifferentiable {
   public var a: Float
 }
 
-// CHECK-AST-LABEL: public struct Foo : Differentiable {
+// CHECK-AST-LABEL: public struct Foo : EuclideanDifferentiable {
 // CHECK-AST:   @differentiable
 // CHECK-AST:   public var a: Float
 // CHECK-AST:   internal init(a: Float)
 // CHECK-AST:   public struct TangentVector
 // CHECK-AST:     public typealias TangentVector = Foo.TangentVector
+// CHECK-AST:   public var vectorView: Foo.TangentVector { get }
 
 // CHECK-SILGEN-LABEL: // Foo.a.getter
 // CHECK-SILGEN-NEXT: sil [transparent] [serialized] [differentiable source 0 wrt 0] [ossa] @$s22derived_differentiable3FooV1aSfvg : $@convention(method) (Foo) -> Float
 
-struct AdditiveTangentIsSelf : AdditiveArithmetic, Differentiable {
+struct AdditiveTangentIsSelf : AdditiveArithmetic, EuclideanDifferentiable {
   var a: Float
   var dummy: PointwiseMultiplicativeDummy
 }
 let _: @differentiable (AdditiveTangentIsSelf) -> Float = { x in
   x.a + x.a
 }
 
-// CHECK-AST-LABEL: internal struct AdditiveTangentIsSelf : AdditiveArithmetic, Differentiable {
+// CHECK-AST-LABEL: internal struct AdditiveTangentIsSelf : AdditiveArithmetic, EuclideanDifferentiable {
 // CHECK-AST:         internal var a: Float
 // CHECK-AST:         internal var dummy: PointwiseMultiplicativeDummy
 // CHECK-AST:         internal init(a: Float, dummy: PointwiseMultiplicativeDummy)
 // CHECK-AST:         internal typealias TangentVector = AdditiveTangentIsSelf
+// The following should not exist because when `Self == Self.TangentVector`, `vectorView` is not synthesized.
+// CHECK-AST-NOT:     internal var vectorView: AdditiveTangentIsSelf { get }
 
-struct TestNoDerivative : Differentiable {
+struct TestNoDerivative : EuclideanDifferentiable {
   var w: Float
   @noDerivative var technicallyDifferentiable: Float
 }
 
-// CHECK-AST-LABEL: internal struct TestNoDerivative : Differentiable {
+// CHECK-AST-LABEL: internal struct TestNoDerivative : EuclideanDifferentiable {
 // CHECK-AST:         var w: Float
 // CHECK-AST:         @noDerivative internal var technicallyDifferentiable: Float
 // CHECK-AST:         internal init(w: Float, technicallyDifferentiable: Float)
 // CHECK-AST:         internal struct TangentVector : Differentiable, AdditiveArithmetic, ElementaryFunctions, VectorProtocol
 // CHECK-AST:           internal typealias TangentVector = TestNoDerivative.TangentVector
+// CHECK-AST:         internal var vectorView: TestNoDerivative.TangentVector { get }
 
 struct TestPointwiseMultiplicative : Differentiable {
   var w: PointwiseMultiplicativeDummy