---

yaml
---
r: 277500
b: refs/heads/tensorflow-merge
c: 1335015
h: refs/heads/master

Author: dan-zheng

[refs]

@@ -1124,7 +1124,7 @@ refs/tags/swift-4.2-DEVELOPMENT-SNAPSHOT-2018-10-29-a: 1b087071edaea398480fb778e
 refs/tags/swift-4.2-DEVELOPMENT-SNAPSHOT-2018-10-30-a: 8bc9e108e1480d9217299984e428c601c7aaac75
 refs/tags/swift-4.2.1-RELEASE: 02a6ca969ea1387475b6caeb69c31186df7d30b6
 refs/tags/swift-DEVELOPMENT-SNAPSHOT-2018-11-01-a: 3b0299288f8287094b9ef587f46df54f42a347af
-refs/heads/tensorflow-merge: dc23a97dd75965198ad97637175a52bd47e3cbd2
+refs/heads/tensorflow-merge: 133501508aa0a8d80caa210d6a25e4d757750952
 refs/heads/TensorFlowLite: b91446471276e37bbfe64767c875f3c7f7102954
 refs/heads/ad-side-effects: 19e0c0de1f59b0929c381925df2e8c72cdf4a728
 refs/heads/add-test-for-asan-compiler-crash: 3cdeecffb47bf28707b299fa2b5bdf0769a4a826

branches/tensorflow-merge/lib/Sema/DerivedConformanceDifferentiable.cpp

@@ -148,10 +148,18 @@ bool DerivedConformance::canDeriveDifferentiable(NominalTypeDecl *nominal,
     if (!structDecl)
       return nullptr;
     // Valid candidate must either:
-    // - Be implicit (previously synthesized).
-    // - Equal nominal (and conform to `AdditiveArithmetic` if flag is true).
+    // 1. Be implicit (previously synthesized).
     if (structDecl->isImplicit())
       return structDecl;
+    // 2. Equal nominal's implicit parent.
+    //    This can occur during mutually recursive constraints. Example:
+    //   `X == X.TangentVector, X.CotangentVector.CotangentVector == X`.
+    if (nominal->isImplicit() && structDecl == nominal->getDeclContext() &&
+        TypeChecker::conformsToProtocol(structDecl->getDeclaredInterfaceType(),
+                                        diffableProto, DC,
+                                        ConformanceCheckFlags::Used))
+      return structDecl;
+    // 3. Equal nominal (and conform to `AdditiveArithmetic` if flag is true).
     if (structDecl == nominal) {
       if (!checkAdditiveArithmetic)
         return structDecl;
@@ -815,12 +823,12 @@ static void addAssociatedTypeAliasDecl(Identifier name,
   auto lookup = nominal->lookupDirect(name);
   assert(lookup.size() < 2 &&
          "Expected at most one associated type named member");
-  // If implicit typealias with the given name already exists in source
+  // If implicit type declaration with the given name already exists in source
   // struct, return it.
   if (lookup.size() == 1) {
-    auto existingAlias = dyn_cast<TypeAliasDecl>(lookup.front());
-    assert(existingAlias && existingAlias->isImplicit() &&
-           "Expected lookup result to be an implicit typealias");
+    auto existingTypeDecl = dyn_cast<TypeDecl>(lookup.front());
+    assert(existingTypeDecl && existingTypeDecl->isImplicit() &&
+           "Expected lookup result to be an implicit type declaration");
     return;
   }
   // Otherwise, create a new typealias.
@@ -898,31 +906,31 @@ getOrSynthesizeAssociatedStructType(DerivedConformance &derived,
   auto *nominal = derived.Nominal;
   auto &C = nominal->getASTContext();
 
-  // Get or synthesize `TangentVector`, `CotangentVector`, and
-  // `AllDifferentiableVariables` structs at once. Synthesizing all three
-  // structs at once is necessary in order to correctly set their mutually
-  // recursive associated types.
+  // Get or synthesize `AllDifferentiableVariables`, `TangentVector`, and
+  // `CotangentVector` structs at once. Synthesizing all three structs at once
+  // is necessary in order to correctly set their mutually recursive associated
+  // types.
+  auto allDiffableVarsStructSynthesis =
+      getOrSynthesizeSingleAssociatedStruct(derived,
+                                            C.Id_AllDifferentiableVariables);
+  auto *allDiffableVarsStruct = allDiffableVarsStructSynthesis.first;
+  if (!allDiffableVarsStruct)
+    return nullptr;
+  bool freshlySynthesized = allDiffableVarsStructSynthesis.second;
+
   auto tangentStructSynthesis =
       getOrSynthesizeSingleAssociatedStruct(derived, C.Id_TangentVector);
   auto *tangentStruct = tangentStructSynthesis.first;
-  bool freshlySynthesized = tangentStructSynthesis.second;
   if (!tangentStruct)
     return nullptr;
+  freshlySynthesized |= tangentStructSynthesis.second;
 
   auto cotangentStructSynthesis =
       getOrSynthesizeSingleAssociatedStruct(derived, C.Id_CotangentVector);
   auto *cotangentStruct = cotangentStructSynthesis.first;
   if (!cotangentStruct)
     return nullptr;
-  assert(freshlySynthesized == cotangentStructSynthesis.second);
-
-  auto allDiffableVarsStructSynthesis =
-      getOrSynthesizeSingleAssociatedStruct(derived,
-                                            C.Id_AllDifferentiableVariables);
-  auto *allDiffableVarsStruct = allDiffableVarsStructSynthesis.first;
-  if (!allDiffableVarsStruct)
-    return nullptr;
-  assert(freshlySynthesized == allDiffableVarsStructSynthesis.second);
+  freshlySynthesized |= cotangentStructSynthesis.second;
 
   // When all structs are freshly synthesized, we check emit warnings for
   // implicit `@noDerivative` members. Checking for fresh synthesis is necessary
@@ -953,9 +961,9 @@ getOrSynthesizeAssociatedStructType(DerivedConformance &derived,
   addAssociatedTypeAliasDecl(C.Id_AllDifferentiableVariables,
                              cotangentStruct, cotangentStruct, TC);
 
+  TC.validateDecl(allDiffableVarsStruct);
   TC.validateDecl(tangentStruct);
   TC.validateDecl(cotangentStruct);
-  TC.validateDecl(allDiffableVarsStruct);
 
   // Sanity checks for synthesized structs.
   assert(DerivedConformance::canDeriveAdditiveArithmetic(tangentStruct,
@@ -1082,7 +1090,7 @@ deriveDifferentiable_AssociatedStruct(DerivedConformance &derived,
   if (allMembersAssocTypesEqualsSelf) {
     auto allDiffableVarsStructSynthesis = getOrSynthesizeSingleAssociatedStruct(
         derived, C.Id_AllDifferentiableVariables);
-    auto allDiffableVarsStruct = allDiffableVarsStructSynthesis.first;
+    auto *allDiffableVarsStruct = allDiffableVarsStructSynthesis.first;
     auto freshlySynthesized = allDiffableVarsStructSynthesis.second;
     // `AllDifferentiableVariables` must conform to `AdditiveArithmetic`.
     // This should be guaranteed.

branches/tensorflow-merge/test/AutoDiff/derived_differentiable_properties.swift

@@ -65,3 +65,23 @@ struct TestKeyPathIterable : Differentiable, KeyPathIterable {
 // CHECK-AST:           internal typealias CotangentVector = TestKeyPathIterable.AllDifferentiableVariables
 // CHECK-AST:         internal typealias TangentVector = TestKeyPathIterable.AllDifferentiableVariables
 // CHECK-AST:         internal typealias CotangentVector = TestKeyPathIterable.AllDifferentiableVariables
+
+struct GenericCotanMember<T : Differentiable> : Differentiable, AdditiveArithmetic {
+  var x: T.CotangentVector
+}
+
+// TODO(TF-316): Revisit after `Differentiable` derived conformances behavior is standardized.
+// `AllDifferentiableVariables` and `CotangentVector` structs need not both be synthesized.
+
+// CHECK-AST-LABEL: @_fieldwiseDifferentiable internal struct GenericCotanMember<T> : Differentiable, AdditiveArithmetic where T : Differentiable {
+// CHECK-AST:         var x: T.CotangentVector
+// CHECK-AST:         internal init(x: T.CotangentVector)
+// CHECK-AST:         internal typealias TangentVector = GenericCotanMember<T>
+// CHECK-AST-LABEL:   @_fieldwiseDifferentiable internal struct AllDifferentiableVariables : Differentiable
+// CHECK-AST:           internal typealias TangentVector = GenericCotanMember<T>
+// CHECK-AST:           internal typealias CotangentVector = GenericCotanMember<T>.CotangentVector
+// CHECK-AST:           internal typealias AllDifferentiableVariables = GenericCotanMember<T>.AllDifferentiableVariables
+// CHECK-AST-LABEL:   @_fieldwiseDifferentiable internal struct CotangentVector : Differentiable, AdditiveArithmetic
+// CHECK-AST:           internal typealias TangentVector = GenericCotanMember<T>.CotangentVector
+// CHECK-AST:           internal typealias CotangentVector = GenericCotanMember<T>
+// CHECK-AST:           internal typealias AllDifferentiableVariables = GenericCotanMember<T>.CotangentVector

branches/tensorflow-merge/test/Sema/struct_differentiable.swift

@@ -247,6 +247,10 @@ extension GenericConstrained : Differentiable
 // expected-warning @+1 {{stored property '_buffer' has no derivative because it does not conform to 'Differentiable'; add '@noDerivative' to make it explicit}}
 extension Array : Differentiable where Element : Differentiable {}
 
+struct TF_260<T : Differentiable> : Differentiable & AdditiveArithmetic {
+  var x: T.CotangentVector
+}
+
 // Test errors.
 
 // Test manually customizing vector space types.