---

yaml
---
r: 262135
b: refs/heads/tensorflow
c: e0cdd32
h: refs/heads/master
i:
  262133: 4bc227f
  262131: 0eddc0b
  262127: a095223

Author: dan-zheng

[refs]

@@ -818,7 +818,7 @@ refs/tags/swift-DEVELOPMENT-SNAPSHOT-2018-04-25-a: 22f738a831d43aff2b9c9773bcb65
 refs/tags/swift-DEVELOPMENT-SNAPSHOT-2018-05-08-a: 7d98cc16689baba5c8a3b90a9329bdcc1a12b4e9
 refs/heads/cherr42: a566ad54b073c2c56ac0a705d0a5bed9743135a5
 "refs/heads/codable_test_comment_fix": fc8f6824f7f347e1e8db55bff62db385c5728b5a
-refs/heads/tensorflow: 31290d09842654ead00dbd0b4852ece9ceb84639
+refs/heads/tensorflow: e0cdd321493fa70fafa3256fd614db405d3616bc
 refs/tags/swift-4.1-DEVELOPMENT-SNAPSHOT-2018-05-11-a: 8126fd7a652e2f70ad6d76505239e34fb2ef3e1a
 refs/tags/swift-4.1-DEVELOPMENT-SNAPSHOT-2018-05-12-a: b3fd3dd84df6717f2e2e9df58c6d7e99fed57086
 refs/tags/swift-4.1-DEVELOPMENT-SNAPSHOT-2018-05-13-a: 71135119579039dc321c5f65d870050fe36efda2

branches/tensorflow/include/swift/AST/DiagnosticsSema.def

@@ -2421,6 +2421,8 @@ ERROR(broken_additive_arithmetic_requirement,none,
       "AdditiveArithmetic protocol is broken: unexpected requirement", ())
 ERROR(broken_vector_numeric_requirement,none,
       "VectorNumeric protocol is broken: unexpected requirement", ())
+ERROR(broken_differentiable_requirement,none,
+      "Differentiable protocol is broken: unexpected requirement", ())
 
 NOTE(codable_extraneous_codingkey_case_here,none,
      "CodingKey case %0 does not match any stored properties", (Identifier))

branches/tensorflow/include/swift/AST/KnownIdentifiers.def

@@ -134,6 +134,8 @@ IDENTIFIER(Parameters)
 // Differentiable
 IDENTIFIER(CotangentVector)
 IDENTIFIER(TangentVector)
+IDENTIFIER(moved)
+IDENTIFIER(tangentVector)
 
 // Kinds of layout constraints
 IDENTIFIER_WITH_NAME(UnknownLayout, "_UnknownLayout")

branches/tensorflow/lib/Sema/CMakeLists.txt

@@ -28,6 +28,7 @@ add_swift_host_library(swiftSema STATIC
   DerivedConformanceError.cpp
   # SWIFT_ENABLE_TENSORFLOW
   DerivedConformanceAdditiveArithmeticVectorNumeric.cpp
+  DerivedConformanceDifferentiable.cpp
   DerivedConformanceKeyPathIterable.cpp
   DerivedConformanceParameterGroup.cpp
   DerivedConformanceParameterized.cpp

branches/tensorflow/lib/Sema/DerivedConformanceDifferentiable.cpp

@@ -74,6 +74,10 @@ bool DerivedConformance::derivesProtocolConformance(DeclContext *DC,
   if (*knownProtocol == KnownProtocolKind::VectorNumeric)
     return canDeriveVectorNumeric(Nominal);
 
+  // SWIFT_ENABLE_TENSORFLOW
+  if (*knownProtocol == KnownProtocolKind::Differentiable)
+    return canDeriveDifferentiable(Nominal);
+
   // SWIFT_ENABLE_TENSORFLOW
   // The only requirement for deriving Parameterized is that there exist some
   // stored properties marked with @TFParameter. The `Parameters` struct can
@@ -274,6 +278,28 @@ ValueDecl *DerivedConformance::getDerivableRequirement(TypeChecker &tc,
       }
     }
 
+    // SWIFT_ENABLE_TENSORFLOW
+    // Differentiable.moved(along:)
+    if (name.isCompoundName() &&
+        name.getBaseName() == ctx.Id_moved) {
+      auto argumentNames = name.getArgumentNames();
+      if (argumentNames.size() == 1 &&
+          argumentNames[0] == ctx.getIdentifier("along")) {
+        return getRequirement(KnownProtocolKind::Differentiable);
+      }
+    }
+
+    // SWIFT_ENABLE_TENSORFLOW
+    // Differentiable.tangentVector(from:)
+    if (name.isCompoundName() &&
+        name.getBaseName() == ctx.Id_tangentVector) {
+      auto argumentNames = name.getArgumentNames();
+      if (argumentNames.size() == 1 &&
+          argumentNames[0] == ctx.getIdentifier("from")) {
+        return getRequirement(KnownProtocolKind::Differentiable);
+      }
+    }
+
     // SWIFT_ENABLE_TENSORFLOW
     // ParameterGroup.update(withGradients:_:)
     if (name.isCompoundName() &&
@@ -325,6 +351,13 @@ ValueDecl *DerivedConformance::getDerivableRequirement(TypeChecker &tc,
     if (name.isSimpleName(ctx.Id_AllKeyPaths))
       return getRequirement(KnownProtocolKind::KeyPathIterable);
 
+    // SWIFT_ENABLE_TENSORFLOW
+    // Differentiable.TangentVector
+    // Differentiable.CotangentVector
+    if (name.isSimpleName(ctx.Id_TangentVector) ||
+        name.isSimpleName(ctx.Id_CotangentVector))
+      return getRequirement(KnownProtocolKind::Differentiable);
+
     // SWIFT_ENABLE_TENSORFLOW
     // Parameterized.Parameters
     if (name.isSimpleName(ctx.Id_Parameters))

branches/tensorflow/lib/Sema/DerivedConformances.cpp

@@ -233,6 +233,22 @@ class DerivedConformance {
   /// \returns the derived member, which will also be added to the type.
   Type deriveVectorNumeric(AssociatedTypeDecl *assocType);
 
+  /// Determine if a Differentiable requirement can be derived for a type.
+  ///
+  /// \returns True if the requirement can be derived.
+  static bool canDeriveDifferentiable(NominalTypeDecl *type);
+
+  /// Derive a Differentiable requirement for a nominal type.
+  ///
+  /// \returns the derived member, which will also be added to the type.
+  ValueDecl *deriveDifferentiable(ValueDecl *requirement);
+
+  /// Derive a Differentiable type witness for a nominal type, if it has
+  /// parameters (stored properties marked with @TFParameter).
+  ///
+  /// \returns the derived member, which will also be added to the type.
+  Type deriveDifferentiable(AssociatedTypeDecl *assocType);
+
   /// Declare a read-only property.
   std::pair<VarDecl *, PatternBindingDecl *>
   declareDerivedProperty(Identifier name, Type propertyInterfaceType,

branches/tensorflow/lib/Sema/DerivedConformances.h

@@ -2385,10 +2385,10 @@ void AttributeChecker::visitDifferentiableAttr(DifferentiableAttr *attr) {
 
   // Predicate checking if a type has associated tangent and cotangent spaces.
   auto hasAssociatedSpaces = [&](Type type) -> bool {
-    // No need to check for cotangent space because every type with a tangent
-    // space also has a cotangent space.
     return (bool)type->getAutoDiffAssociatedVectorSpace(
-        AutoDiffAssociatedVectorSpaceKind::Tangent, lookupConformance);
+               AutoDiffAssociatedVectorSpaceKind::Tangent, lookupConformance) &&
+           (bool)type->getAutoDiffAssociatedVectorSpace(
+               AutoDiffAssociatedVectorSpaceKind::Cotangent, lookupConformance);
   };
 
   // Check that the user has only selected wrt params with allowed types.

branches/tensorflow/lib/Sema/TypeCheckAttr.cpp

@@ -5296,6 +5296,10 @@ ValueDecl *TypeChecker::deriveProtocolRequirement(DeclContext *DC,
   case KnownProtocolKind::VectorNumeric:
     return derived.deriveVectorNumeric(Requirement);
 
+  // SWIFT_ENABLE_TENSORFLOW
+  case KnownProtocolKind::Differentiable:
+    return derived.deriveDifferentiable(Requirement);
+
   default:
     return nullptr;
   }
@@ -5328,6 +5332,8 @@ Type TypeChecker::deriveTypeWitness(DeclContext *DC,
     return derived.deriveParameterGroup(AssocType);
   case KnownProtocolKind::VectorNumeric:
     return derived.deriveVectorNumeric(AssocType);
+  case KnownProtocolKind::Differentiable:
+    return derived.deriveDifferentiable(AssocType);
   default:
     return nullptr;
   }

branches/tensorflow/lib/Sema/TypeCheckProtocol.cpp

@@ -104,6 +104,9 @@ extension Tensor : ShapedVectorNumeric where Scalar : Numeric {}
 extension Tensor : Differentiable where Scalar : FloatingPoint {
   public typealias TangentVector = Tensor
   public typealias CotangentVector = Tensor
+  public func tangentVector(from cotangent: CotangentVector) -> TangentVector {
+    return cotangent
+  }
 }
 
 //===----------------------------------------------------------------------===//

branches/tensorflow/stdlib/public/TensorFlow/Ops.swift

@@ -87,11 +87,16 @@ public extension Differentiable
   }
 }
 
+// FIXME: This is currently commented because the where clause leads to
+// associated type inference which conflicts with `Differentiable` derived
+// conformances.
+/*
 public extension Differentiable where TangentVector == CotangentVector {
   func tangentVector(from cotangent: CotangentVector) -> TangentVector {
     return cotangent
   }
 }
+*/
 
 //===----------------------------------------------------------------------===//
 // Differential Operators

branches/tensorflow/stdlib/public/core/AutoDiff.swift

@@ -1852,6 +1852,9 @@ extension ${Self} : VectorNumeric {
 extension ${Self} : Differentiable {
   public typealias TangentVector = ${Self}
   public typealias CotangentVector = ${Self}
+  public func tangentVector(from cotangent: CotangentVector) -> TangentVector {
+    return cotangent
+  }
 }
 
 //===----------------------------------------------------------------------===//

branches/tensorflow/stdlib/public/core/FloatingPointTypes.swift.gyb

@@ -52,6 +52,9 @@ extension Space : Differentiable {
   func moved(along: TangentSpace) -> Space {
     return Space(x: x + along.dx, y: y + along.dy)
   }
+  func tangentVector(from cotangent: CotangentVector) -> TangentVector {
+    return cotangent
+  }
 }
 
 E2EDifferentiablePropertyTests.test("computed property") {
@@ -110,6 +113,9 @@ extension ProductSpaceOtherTangent : Differentiable {
   func moved(along: ProductSpaceOtherTangentTangentSpace) -> ProductSpaceOtherTangent {
     return ProductSpaceOtherTangent(x: x + along.x, y: y + along.y)
   }
+  func tangentVector(from cotangent: CotangentVector) -> TangentVector {
+    return cotangent
+  }
 }
 
 E2EDifferentiablePropertyTests.test("fieldwise product space, other tangent") {

branches/tensorflow/test/AutoDiff/e2e_differentiable_property.swift

@@ -12,6 +12,8 @@ public struct Vector : AdditiveArithmetic, VectorNumeric, Differentiable, Equata
   public var y: Float
   public var nonTrivialStuff = NonTrivialStuff()
   public typealias TangentVector = Vector
+  public typealias CotangentVector = Vector
+  public func tangentVector(from cotangent: CotangentVector) -> TangentVector { return cotangent }
   public typealias Scalar = Float
   public static var zero: Vector { return Vector(0) }
   public init(_ scalar: Float) { self.x = scalar; self.y = scalar }

branches/tensorflow/test/AutoDiff/refcounting.swift

@@ -0,0 +1,89 @@
+// SWIFT_ENABLE_TENSORFLOW
+// RUN: %target-swift-frontend -typecheck -verify %s -verify-ignore-unknown
+
+struct Simple : VectorNumeric, Differentiable {
+  var w: Float
+  var b: Float
+}
+var simple = Simple(w: 1, b: 1)
+assert(simple.moved(along: simple) == simple + simple)
+assert(simple.tangentVector(from: simple) == simple)
+
+// Test type with mixed members.
+struct Mixed : VectorNumeric, Differentiable {
+  var simple: Simple
+  var float: Float
+}
+var mixed = Mixed(simple: simple, float: 1)
+assert(mixed.moved(along: mixed) == mixed + mixed)
+assert(mixed.tangentVector(from: mixed) == mixed)
+
+// Test type with generic members that conform to `Differentiable`.
+// Since `T == T.TangentVector == T.CotangentVector`,
+// it's only necessary to synthesis typealiases:
+// `typealias TangentVector = Generic`
+// `typealias CotangentVector = Generic`
+struct Generic<T> : VectorNumeric, Differentiable
+  where T : Differentiable, T == T.TangentVector, T == T.CotangentVector
+{
+  var w: T
+  var b: T
+}
+var generic = Generic<Double>(w: 1, b: 1)
+assert(generic.moved(along: generic) == generic + generic)
+assert(generic.tangentVector(from: generic) == generic)
+
+// Test type with manual definition of vector space types to `Self`.
+struct VectorSpacesEqualSelf : VectorNumeric, Differentiable {
+  var w: Float
+  var b: Float
+  typealias TangentVector = VectorSpacesEqualSelf
+  typealias CotangentVector = VectorSpacesEqualSelf
+}
+
+// TODO: Support the cases below after `Differentiable` derived conformances
+// limitations are lifted.
+
+/*
+// Test type with generic members that conform to `Differentiable`.
+// Since it's not the case that
+// `T == T.TangentVector == T.CotangentVector`,
+// it's necessary to synthesize new vector space struct types.
+struct GenericNeedsVectorSpaceStructs<T> : VectorNumeric, Differentiable
+  where T : VectorNumeric, T : Differentiable
+{
+  var w: T
+  var b: T
+}
+
+// Test type that doesn't conform to `VectorNumeric`.
+// Thus, `Self` cannot be used as `TangentVector` or `CotangentVector`.
+// Vector space structs types must be synthesized.
+// Note: it would be nice to emit a warning if conforming `Self` to
+// `VectorNumeric` is possible.
+struct NotVectorNumeric : Differentiable {
+  var w: Float
+  var b: Float
+}
+*/
+
+// Test errors.
+
+// Test manually customizing vector space types.
+// Thees should fail. Synthesis is semantically unsupported if vector space
+// types are customized.
+struct VectorSpaceTypeAlias : VectorNumeric, Differentiable { // expected-error {{type 'VectorSpaceTypeAlias' does not conform to protocol 'Differentiable'}}
+  var w: Float
+  var b: Float
+  typealias TangentVector = Simple
+}
+struct VectorSpaceCustomStruct : VectorNumeric, Differentiable { // expected-error {{type 'VectorSpaceCustomStruct' does not conform to protocol 'Differentiable'}}
+  var w: Float
+  var b: Float
+  struct CotangentVector : VectorNumeric, Differentiable {
+    var w: Float.CotangentVector
+    var b: Float.CotangentVector
+    typealias TangentVector = VectorSpaceCustomStruct.CotangentVector
+    typealias CotangentVector = VectorSpaceCustomStruct.CotangentVector
+  }
+}