---

yaml
---
r: 262127
b: refs/heads/tensorflow
c: 78c9f57
h: refs/heads/master
i:
  262125: 406f4db
  262123: 56059af
  262119: a05fe24
  262111: 16bc367

Author: rxwei

[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: ba9b37e342043993abbb3b2c566870ee56b3f4bc
+refs/heads/tensorflow: 78c9f57e76df3bd298db5767854a52776f284d09
 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/ASTContext.h

@@ -104,6 +104,7 @@ namespace swift {
   class VarDecl;
   class UnifiedStatsReporter;
   // SWIFT_ENABLE_TENSORFLOW
+  enum class AutoDiffAssociatedVectorSpaceKind : unsigned;
   class VectorSpace;
 
   enum class KnownProtocolKind : uint8_t;
@@ -269,6 +270,10 @@ class ASTContext final {
   /// Cache of remapped types (useful for diagnostics).
   llvm::StringMap<Type> RemappedTypes;
 
+  /// Cache of autodiff-associated vector spaces.
+  llvm::DenseMap<std::pair<Type, unsigned>,
+                 Optional<VectorSpace>> AutoDiffVectorSpaces;
+
 private:
   /// \brief The current generation number, which reflects the number of
   /// times that external modules have been loaded.
@@ -952,11 +957,6 @@ class ASTContext final {
     return LangOpts.isSwiftVersionAtLeast(major, minor);
   }
 
-  // SWIFT_ENABLE_TENSORFLOW
-  /// Compute the tangent space of this manifold, if the given type represents a
-  /// differentiable manifold.
-  Optional<VectorSpace> getTangentSpace(CanType type, ModuleDecl *module);
-
 private:
   friend Decl;
   Optional<RawComment> getRawComment(const Decl *D);

branches/tensorflow/include/swift/AST/AutoDiff.h

@@ -315,12 +315,8 @@ class AutoDiffAssociatedFunctionIdentifier : public llvm::FoldingSetNode {
 };
 
 /// The kind of an associated type.
-struct AutoDiffAssociatedTypeKind {
-  enum innerty : uint8_t { TangentVector = 0, CotangentVector = 1 } rawValue;
-
-  AutoDiffAssociatedTypeKind() = default;
-  AutoDiffAssociatedTypeKind(innerty rawValue) : rawValue(rawValue) {}
-  operator innerty() const { return rawValue; }
+enum class AutoDiffAssociatedVectorSpaceKind : unsigned {
+  Tangent = 0, Cotangent = 1
 };
 
 /// Automatic differentiation utility namespace.
@@ -352,10 +348,8 @@ bool getBuiltinAutoDiffApplyConfig(StringRef operationName,
 } // end namespace autodiff
 
 class BuiltinFloatType;
-class NominalTypeDecl;
-class StructDecl;
+class NominalOrBoundGenericNominalType;
 class TupleType;
-class EnumDecl;
 
 /// A type that represents a vector space.
 class VectorSpace {
@@ -366,33 +360,23 @@ class VectorSpace {
     BuiltinFloat,
     /// A type that conforms to `VectorNumeric`.
     Vector,
-    /// A product of vector spaces as a struct.
-    Struct,
     /// A product of vector spaces as a tuple.
     Tuple,
-    /// A union of vector spaces.
-    Enum
   };
 
 private:
   Kind kind;
   union Value {
-    // BuiltinRealScalar
+    // Builtin float
     BuiltinFloatType *builtinFPType;
-    // RealVector
-    NominalTypeDecl *realNominalType;
-    // ProductStruct
-    StructDecl *structDecl;
-    // ProductTuple
+    // Vector
+    Type vectorType;
+    // Tuple
     TupleType *tupleType;
-    // Sum
-    EnumDecl *enumDecl;
 
     Value(BuiltinFloatType *builtinFP) : builtinFPType(builtinFP) {}
-    Value(NominalTypeDecl *nominal) : realNominalType(nominal) {}
-    Value(StructDecl *structDecl) : structDecl(structDecl) {}
+    Value(Type vectorType) : vectorType(vectorType) {}
     Value(TupleType *tupleType) : tupleType(tupleType) {}
-    Value(EnumDecl *enumDecl) : enumDecl(enumDecl) {}
   } value;
 
   VectorSpace(Kind kind, Value value)
@@ -401,51 +385,37 @@ class VectorSpace {
 public:
   VectorSpace() = delete;
 
-  static VectorSpace
-  getBuiltinRealScalarSpace(BuiltinFloatType *builtinFP) {
+  static VectorSpace getBuiltinFloat(BuiltinFloatType *builtinFP) {
     return {Kind::BuiltinFloat, builtinFP};
   }
-  static VectorSpace getRealVectorSpace(NominalTypeDecl *typeDecl) {
-    return {Kind::Vector, typeDecl};
-  }
-  static VectorSpace getStruct(StructDecl *structDecl) {
-    return {Kind::Struct, structDecl};
+  static VectorSpace getVector(Type vectorType) {
+    return {Kind::Vector, vectorType};
   }
   static VectorSpace getTuple(TupleType *tupleTy) {
     return {Kind::Tuple, tupleTy};
   }
-  static VectorSpace getEnum(EnumDecl *enumDecl) {
-    return {Kind::Enum, enumDecl};
-  }
 
-  bool isBuiltinFloat() const {
-    return kind == Kind::BuiltinFloat;
-  }
+  bool isBuiltinFloat() const { return kind == Kind::BuiltinFloat; }
   bool isVector() const { return kind == Kind::Vector; }
-  bool isStruct() const { return kind == Kind::Struct; }
   bool isTuple() const { return kind == Kind::Tuple; }
 
   Kind getKind() const { return kind; }
   BuiltinFloatType *getBuiltinFloat() const {
     assert(kind == Kind::BuiltinFloat);
     return value.builtinFPType;
   }
-  NominalTypeDecl *getVector() const {
+  Type getVector() const {
     assert(kind == Kind::Vector);
-    return value.realNominalType;
-  }
-  StructDecl *getStruct() const {
-    assert(kind == Kind::Struct);
-    return value.structDecl;
+    return value.vectorType;
   }
   TupleType *getTuple() const {
     assert(kind == Kind::Tuple);
     return value.tupleType;
   }
-  EnumDecl *getEnum() const {
-    assert(kind == Kind::Enum);
-    return value.enumDecl;
-  }
+
+  Type getType() const;
+  CanType getCanonicalType() const;
+  NominalTypeDecl *getNominal() const;
 };
 
 } // end namespace swift

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

@@ -374,8 +374,6 @@ ERROR(autodiff_unsupported_type,none,
       "differentiating '%0' is not supported yet", (Type))
 ERROR(autodiff_function_not_differentiable,none,
       "function is not differentiable", ())
-ERROR(autodiff_property_not_differentiable,none,
-      "property is not differentiable", ())
 NOTE(autodiff_function_generic_functions_unsupported,none,
      "differentiating generic functions is not supported yet", ())
 NOTE(autodiff_value_defined_here,none,

branches/tensorflow/include/swift/AST/TensorFlow.h

@@ -20,7 +20,6 @@
 
 #include "swift/Basic/LLVM.h"
 #include "llvm/ADT/DenseMap.h"
-#include "llvm/ADT/SetVector.h"
 
 namespace swift {
   class CanType;
@@ -93,12 +92,7 @@ namespace tf {
     bool containsTensorFlowValue(Type ty, bool checkHigherOrderFunctions);
 
   private:
-    bool containsTensorFlowValueImpl(
-        Type ty, bool checkHigherOrderFunctions,
-        llvm::SetVector<NominalTypeDecl *> &parentDecls);
-
-    bool structContainsTensorFlowValue(
-        StructDecl *decl, llvm::SetVector<NominalTypeDecl *> &parentDecls);
+    bool structContainsTensorFlowValue(StructDecl *decl);
   };
 
   /// This class provides a single source of truth for the set of types that are

branches/tensorflow/include/swift/AST/Types.h

@@ -1079,7 +1079,7 @@ class alignas(1 << TypeAlignInBits) TypeBase {
   TypeTraitResult canBeClass();
 
   // SWIFT_ENABLE_TENSORFLOW
-  /// Returns the associated tangent or cotangent type. Returns the null type if
+  /// Return the associated tangent or cotangent type. Return the null type if
   /// there is no associated tangent/cotangent type.
   ///
   /// `kind` specifies whether to return the tangent or cotangent type.
@@ -1090,8 +1090,9 @@ class alignas(1 << TypeAlignInBits) TypeBase {
   /// associated tangent/cotangent type is the elementwise tangent/cotangent
   /// type of its elements. If the type is a builtin float, then the associated
   /// tangent/cotangent type is itself. Otherwise, there is no associated type.
-  Type getAutoDiffAssociatedType(AutoDiffAssociatedTypeKind kind,
-                                 LookupConformanceFn lookupConformance);
+  Optional<VectorSpace>
+  getAutoDiffAssociatedVectorSpace(AutoDiffAssociatedVectorSpaceKind kind,
+                                   LookupConformanceFn lookupConformance);
 
 private:
   // Make vanilla new/delete illegal for Types.

branches/tensorflow/lib/AST/ASTContext.cpp

@@ -5195,79 +5195,6 @@ LayoutConstraint LayoutConstraint::getLayoutConstraint(LayoutConstraintKind Kind
 }
 
 // SWIFT_ENABLE_TENSORFLOW
-Optional<VectorSpace> ASTContext::getTangentSpace(CanType type,
-                                                  ModuleDecl *module) {
-  auto lookup = getImpl().VectorSpaces.find(type);
-  if (lookup != getImpl().VectorSpaces.end())
-    return lookup->getSecond();
-  // A helper that is used to cache the computed tangent space for the
-  // specified type and retuns the same tangent space.
-  auto cache = [&](Optional<VectorSpace> space) {
-    getImpl().VectorSpaces.insert({type, space});
-    return space;
-  };
-  // `Builtin.FP<...>` is a builtin real scalar space.
-  if (auto *fpType = type->getAs<BuiltinFloatType>())
-    return cache(VectorSpace::getBuiltinRealScalarSpace(fpType));
-  // Look up conformance to `Differentiable`.
-  auto *diffableProto = getProtocol(KnownProtocolKind::Differentiable);
-  if (module->lookupConformance(type, diffableProto).hasValue()) {
-    auto tangentType = type->getAutoDiffAssociatedType(
-        AutoDiffAssociatedTypeKind::TangentVector,
-        LookUpConformanceInModule(module));
-    assert(tangentType);
-    auto *nomTypeDecl = tangentType->getAnyNominal();
-    assert(nomTypeDecl);
-    return VectorSpace::getRealVectorSpace(nomTypeDecl);
-  }
-  // Nominal types can be either a struct or an enum.
-  if (auto *nominal = type->getAnyNominal()) {
-    // Fixed-layout struct types, each of whose elements has a tangent space,
-    // are a product of those tangent spaces.
-    if (auto *structDecl = dyn_cast<StructDecl>(nominal)) {
-      if (structDecl->getFormalAccess() >= AccessLevel::Public &&
-          !structDecl->getAttrs().hasAttribute<FixedLayoutAttr>())
-        return cache(None);
-      auto allMembersHaveTangentSpace =
-          llvm::all_of(structDecl->getStoredProperties(), [&](VarDecl *v) {
-            return (bool)getTangentSpace(v->getType()->getCanonicalType(),
-                                         module);
-          });
-      if (allMembersHaveTangentSpace)
-        return cache(VectorSpace::getStruct(structDecl));
-    }
-    // Frozen enum types, all of whose payloads have a tangent space, are a
-    // sum of the product of payloads in each case.
-    if (auto *enumDecl = dyn_cast<EnumDecl>(nominal)) {
-      if (enumDecl->getFormalAccess() >= AccessLevel::Public &&
-          !enumDecl->getAttrs().hasAttribute<FrozenAttr>())
-        return cache(None);
-      if (enumDecl->isIndirect())
-        return cache(None);
-      auto allMembersHaveTangentSpace =
-        llvm::all_of(enumDecl->getAllCases(), [&](EnumCaseDecl *cd) {
-          return llvm::all_of(cd->getElements(), [&](EnumElementDecl *eed) {
-            return llvm::all_of(*eed->getParameterList(), [&](ParamDecl *pd) {
-              return (bool)
-                  getTangentSpace(pd->getType()->getCanonicalType(), module);
-            });
-          });
-        });
-      if (allMembersHaveTangentSpace)
-        return cache(VectorSpace::getEnum(enumDecl));
-    }
-  }
-  // Tuple types, each of whose elements has a tangent space, are a product of
-  // those tangent space.
-  if (TupleType *tupleType = type->getAs<TupleType>())
-    if (llvm::all_of(tupleType->getElementTypes(), [&](Type t) {
-            return (bool)getTangentSpace(t->getCanonicalType(), module); }))
-      return cache(VectorSpace::getTuple(tupleType));
-  // Otherwise, the type does not have a tangent space. That is, it does not
-  // support differentiation.
-  return cache(None);
-}
-
 AutoDiffParameterIndices *
 AutoDiffParameterIndices::get(llvm::SmallBitVector indices, ASTContext &C) {
   auto &foldingSet = C.getImpl().AutoDiffParameterIndicesSet;

branches/tensorflow/lib/AST/AutoDiff.cpp

@@ -282,3 +282,22 @@ void AutoDiffParameterIndicesBuilder::setParameter(unsigned paramIndex) {
   assert(paramIndex < parameters.size() && "paramIndex out of bounds");
   parameters.set(paramIndex);
 }
+
+Type VectorSpace::getType() const {
+  switch (kind) {
+  case Kind::BuiltinFloat:
+    return value.builtinFPType;
+  case Kind::Vector:
+    return value.vectorType;
+  case Kind::Tuple:
+    return value.tupleType;
+  }
+}
+
+CanType VectorSpace::getCanonicalType() const {
+  return getType()->getCanonicalType();
+}
+
+NominalTypeDecl *VectorSpace::getNominal() const {
+  return getVector()->getNominalOrBoundGenericNominal();
+}