Fix merge fallout

Author: Eugene Burmako

include/swift/AST/ASTContext.h

@@ -291,18 +291,6 @@ class ASTContext final {
   /// across invocations of both the parser and the type-checker.
   unsigned NextAutoClosureDiscriminator = 0;
 
-  // SWIFT_ENABLE_TENSORFLOW
-
-  /// Cache of `@differentiable` attributes keyed by parameter indices. Used to
-  /// diagnose duplicate `@differentiable` attributes for the same key.
-  // NOTE(TF-680): relaxing the uniqueness condition to use derivative generic
-  // signature as a key is possible. It requires derivative generic signature
-  // mangling to avoid name collisions for SIL derivative functions with the
-  // same parameter indices but different derivative generic signatures.
-  llvm::DenseMap<std::pair<Decl *, IndexSubset *>, DifferentiableAttr *>
-      DifferentiableAttrs;
-  // SWIFT_ENABLE_TENSORFLOW END
-
   /// Cached mapping from types to their associated tangent spaces.
   llvm::DenseMap<Type, Optional<TangentSpace>> AutoDiffTangentSpaces;
 

lib/AST/ASTScopeCreation.cpp

@@ -1725,12 +1725,6 @@ NullablePtr<AbstractStorageDecl>
 SpecializeAttributeScope::getEnclosingAbstractStorageDecl() const {
   return getParent().get()->getEnclosingAbstractStorageDecl();
 }
-// SWIFT_ENABLE_TENSORFLOW
-NullablePtr<AbstractStorageDecl>
-DifferentiableAttributeScope::getEnclosingAbstractStorageDecl() const {
-  return getParent().get()->getEnclosingAbstractStorageDecl();
-}
-// SWIFT_ENABLE_TENSORFLOW END
 NullablePtr<AbstractStorageDecl>
 DifferentiableAttributeScope::getEnclosingAbstractStorageDecl() const {
   return getParent().get()->getEnclosingAbstractStorageDecl();

lib/AST/Attr.cpp

@@ -1522,33 +1522,6 @@ DifferentiableAttr::create(AbstractFunctionDecl *original, bool implicit,
                                       std::move(vjp), derivativeGenSig);
 }
 
-// SWIFT_ENABLE_TENSORFLOW
-bool DifferentiableAttr::hasComputedParameterIndices() const {
-  return ParameterIndicesAndBit.getInt();
-}
-
-IndexSubset *DifferentiableAttr::getParameterIndices() const {
-  assert(getOriginalDeclaration() &&
-         "Original declaration must have been resolved");
-  auto &ctx = getOriginalDeclaration()->getASTContext();
-  return evaluateOrDefault(
-      ctx.evaluator,
-      DifferentiableAttributeParameterIndicesRequest{
-          const_cast<DifferentiableAttr *>(this), getOriginalDeclaration()},
-      nullptr);
-}
-
-void DifferentiableAttr::setParameterIndices(IndexSubset *paramIndices) {
-  assert(getOriginalDeclaration() &&
-         "Original declaration must have been resolved");
-  auto &ctx = getOriginalDeclaration()->getASTContext();
-  ctx.evaluator.cacheOutput(
-      DifferentiableAttributeParameterIndicesRequest{
-          const_cast<DifferentiableAttr *>(this), getOriginalDeclaration()},
-      std::move(paramIndices));
-}
-// SWIFT_ENABLE_TENSORFLOW END
-
 void DifferentiableAttr::setOriginalDeclaration(Decl *originalDeclaration) {
   assert(originalDeclaration && "Original declaration must be non-null");
   assert(!OriginalDeclaration &&

lib/AST/Type.cpp

@@ -4806,145 +4806,6 @@ Type TypeBase::openAnyExistentialType(OpenedArchetypeType *&opened) {
   return opened;
 }
 
-// SWIFT_ENABLE_TENSORFLOW
-// Makes a function with the same generic signature and ExtInfo as `copy`, but
-// with `params` parameters and `retTy` return type.
-static AnyFunctionType *
-makeFunctionType(AnyFunctionType *copy, ArrayRef<AnyFunctionType::Param> params,
-                 Type retTy, GenericSignature genericSignature) {
-  if (!genericSignature)
-    if (auto *genericFunctionType = copy->getAs<GenericFunctionType>())
-      genericSignature = genericFunctionType->getGenericSignature();
-  if (genericSignature)
-    return GenericFunctionType::get(genericSignature, params, retTy,
-                                    copy->getExtInfo());
-  return FunctionType::get(params, retTy, copy->getExtInfo());
-}
-
-AnyFunctionType *AnyFunctionType::getAutoDiffDerivativeFunctionType(
-    IndexSubset *indices, unsigned resultIndex,
-    AutoDiffDerivativeFunctionKind kind, LookupConformanceFn lookupConformance,
-    GenericSignature whereClauseGenSig, bool makeSelfParamFirst) {
-  // JVP: (T...) -> ((R...),
-  //                 (T.TangentVector...) -> (R.TangentVector...))
-  // VJP: (T...) -> ((R...),
-  //                 (R.TangentVector...) -> (T.TangentVector...))
-  //
-  // Note that both can be written as "(T...) -> ((R...), Closure)", so we build
-  // "Closure" and then use common code to wrap "Closure" in the outer function
-  // type.
-
-  assert(!indices->isEmpty() && "there must be at least one wrt index");
-
-  auto &ctx = getASTContext();
-
-  // Get differentiability parameter types.
-  SmallVector<Type, 8> diffParamTypes;
-  autodiff::getSubsetParameterTypes(indices, this, diffParamTypes,
-                                    /*reverseCurryLevels*/ !makeSelfParamFirst);
-
-  // Unwrap curry levels. At most, two parameter lists are necessary, for
-  // curried method types with a `(Self)` parameter list.
-  SmallVector<AnyFunctionType *, 2> curryLevels;
-  auto *currentLevel = castTo<AnyFunctionType>();
-  for (unsigned i : range(2)) {
-    (void)i;
-    if (currentLevel == nullptr)
-      break;
-    curryLevels.push_back(currentLevel);
-    currentLevel = currentLevel->getResult()->getAs<AnyFunctionType>();
-  }
-
-  Type originalResult = curryLevels.back()->getResult();
-
-  // Build the closure type, which is different depending on whether this is a
-  // JVP or VJP.
-  Type closure;
-  switch (kind) {
-  case AutoDiffDerivativeFunctionKind::JVP: {
-    // closure is the JVP "differential":
-    //   (T.TangentVector...) -> (R.TangentVector...)
-    SmallVector<AnyFunctionType::Param, 8> differentialParams;
-    for (auto diffParamType : diffParamTypes)
-      differentialParams.push_back(AnyFunctionType::Param(
-          diffParamType->getAutoDiffTangentSpace(lookupConformance)
-              ->getType()));
-
-    SmallVector<TupleTypeElt, 8> differentialResults;
-    if (auto *resultTuple = originalResult->getAs<TupleType>()) {
-      auto resultTupleEltType = resultTuple->getElementType(resultIndex);
-      differentialResults.push_back(resultTupleEltType
-          ->getAutoDiffTangentSpace(lookupConformance)->getType());
-    } else {
-      assert(resultIndex == 0 && "resultIndex out of bounds");
-      differentialResults.push_back(
-          originalResult->getAutoDiffTangentSpace(lookupConformance)
-              ->getType());
-    }
-    Type differentialResult =
-        differentialResults.size() > 1
-            ? TupleType::get(differentialResults, ctx)
-            : differentialResults[0].getType();
-
-    closure = FunctionType::get(differentialParams, differentialResult);
-    break;
-  }
-  case AutoDiffDerivativeFunctionKind::VJP: {
-    // closure is the VJP "pullback":
-    //   (R.TangentVector...) -> (T.TangentVector...)
-    SmallVector<AnyFunctionType::Param, 8> pullbackParams;
-    if (auto *resultTuple = originalResult->getAs<TupleType>()) {
-      auto resultTupleEltType = resultTuple->getElementType(resultIndex);
-      pullbackParams.push_back(
-          AnyFunctionType::Param(resultTupleEltType
-              ->getAutoDiffTangentSpace(lookupConformance)
-                  ->getType()));
-    } else {
-      assert(resultIndex == 0 && "resultIndex out of bounds");
-      pullbackParams.push_back(
-          AnyFunctionType::Param(originalResult
-              ->getAutoDiffTangentSpace(lookupConformance)
-                  ->getType()));
-    }
-
-    SmallVector<TupleTypeElt, 8> pullbackResults;
-    for (auto diffParamType : diffParamTypes)
-      pullbackResults.push_back(
-          diffParamType->getAutoDiffTangentSpace(lookupConformance)
-              ->getType());
-    Type pullbackResult = pullbackResults.size() > 1
-                              ? TupleType::get(pullbackResults, ctx)
-                              : pullbackResults[0].getType();
-
-    closure = FunctionType::get(pullbackParams, pullbackResult);
-    break;
-  }
-  }
-  assert(closure && "should have built a closure");
-
-  // Build "(T...) -> ((R...), Closure)".
-  SmallVector<TupleTypeElt, 2> retElts;
-  retElts.push_back(originalResult);
-  retElts.push_back(closure);
-  auto retTy = TupleType::get(retElts, ctx);
-  auto *derivativeFunction = makeFunctionType(
-      curryLevels.back(), curryLevels.back()->getParams(), retTy,
-      curryLevels.size() == 1 ? whereClauseGenSig : nullptr);
-
-  // Wrap the derivative function type in additional curry levels.
-  auto curryLevelsWithoutLast =
-      ArrayRef<AnyFunctionType *>(curryLevels).drop_back(1);
-  for (auto pair : enumerate(llvm::reverse(curryLevelsWithoutLast))) {
-    unsigned i = pair.index();
-    AnyFunctionType *curryLevel = pair.value();
-    derivativeFunction = makeFunctionType(
-        curryLevel, curryLevel->getParams(), derivativeFunction,
-        i == curryLevelsWithoutLast.size() - 1 ? whereClauseGenSig : nullptr);
-  }
-
-  return derivativeFunction;
-}
-
 bool TypeBase::hasOpaqueArchetypePropertiesOrCases() {
   if (auto *structDecl = getStructOrBoundGenericStruct()) {
     for (auto *field : structDecl->getStoredProperties()) {

lib/AST/TypeCheckRequests.cpp

@@ -1062,7 +1062,7 @@ void swift::simple_display(llvm::raw_ostream &out,
 Optional<IndexSubset *>
 DifferentiableAttributeParameterIndicesRequest::getCachedResult() const {
   auto *attr = std::get<0>(getStorage());
-  if (attr->hasComputedParameterIndices())
+  if (attr->hasBeenTypeChecked())
     return attr->ParameterIndicesAndBit.getPointer();
   return None;
 }

lib/Sema/TypeCheckAttr.cpp

@@ -121,10 +121,6 @@ class AttributeChecker : public AttributeVisitor<AttributeChecker> {
   IGNORED_ATTR(ProjectedValueProperty)
   IGNORED_ATTR(ReferenceOwnership)
   IGNORED_ATTR(OriginallyDefinedIn)
-  // TODO(TF-830): Upstream `@transpose` attribute type-checking from tensorflow
-  // branch.
-  IGNORED_ATTR(Transpose)
-
   // SWIFT_ENABLE_TENSORFLOW
   // TODO(TF-715): Allow @quoted on more decls.
   IGNORED_ATTR(Quoted)
@@ -265,7 +261,6 @@ class AttributeChecker : public AttributeVisitor<AttributeChecker> {
   void visitDifferentiableAttr(DifferentiableAttr *attr);
   void visitDerivativeAttr(DerivativeAttr *attr);
   // SWIFT_ENABLE_TENSORFLOW
-  void visitDifferentiableAttr(DifferentiableAttr *attr);
   void visitTransposeAttr(TransposeAttr *attr);
   // TODO(TF-999): Remove deprecated `@differentiating` attribute.
   void visitDifferentiatingAttr(DerivativeAttr *attr);
@@ -4450,121 +4445,6 @@ static bool tangentVectorEqualsSelf(Type type, DeclContext *DC) {
 };
 
 // SWIFT_ENABLE_TENSORFLOW
-// Finds a derivative function declaration using the given function specifier,
-// original function declaration, expected type, and "is valid" predicate. If no
-// valid derivative function is found, emits diagnostics and returns false.
-static FuncDecl *findAutoDiffDerivativeFunction(
-    DeclNameRefWithLoc specifier, AbstractFunctionDecl *original, Type expectedTy,
-    std::function<bool(AbstractFunctionDecl *)> isValid) {
-  auto &ctx = original->getASTContext();
-  auto &diags = ctx.Diags;
-  auto noneValidDiagnostic = [&]() {
-    diags.diagnose(specifier.Loc,
-                   diag::differentiable_attr_overload_not_found, specifier.Name,
-                   expectedTy);
-  };
-  auto ambiguousDiagnostic = [&]() {
-    diags.diagnose(specifier.Loc, diag::attr_ambiguous_reference_to_decl,
-                   specifier.Name, "differentiable");
-  };
-  auto notFunctionDiagnostic = [&]() {
-    diags.diagnose(specifier.Loc,
-                   diag::differentiable_attr_derivative_not_function,
-                   specifier.Name);
-  };
-  std::function<void()> invalidTypeContextDiagnostic = [&]() {
-    diags.diagnose(specifier.Loc,
-                   diag::differentiable_attr_function_not_same_type_context,
-                   specifier.Name);
-  };
-
-  // Returns true if the original function and derivative function candidate are
-  // defined in compatible type contexts. If the original function and the
-  // derivative function have different parents, or if they both have no type
-  // context and are in different modules, return false.
-  std::function<bool(AbstractFunctionDecl *)> hasValidTypeContext =
-      [&](AbstractFunctionDecl *func) {
-        // Check if both functions are top-level.
-        if (!original->getInnermostTypeContext() &&
-            !func->getInnermostTypeContext() &&
-            original->getParentModule() == func->getParentModule())
-          return true;
-        // Check if both functions are defined in the same type context.
-        if (auto typeCtx1 = original->getInnermostTypeContext())
-          if (auto typeCtx2 = func->getInnermostTypeContext())
-            return typeCtx1->getSelfNominalTypeDecl() ==
-                   typeCtx2->getSelfNominalTypeDecl();
-        return original->getParent() == func->getParent();
-      };
-
-  auto isABIPublic = [&](AbstractFunctionDecl *func) {
-    return func->getFormalAccess() >= AccessLevel::Public ||
-           func->getAttrs().hasAttribute<InlinableAttr>() ||
-           func->getAttrs().hasAttribute<UsableFromInlineAttr>();
-  };
-
-  // If the original function is exported (i.e. it is public or
-  // `@usableFromInline`), then the derivative functions must also be exported.
-  // Returns true on error.
-  auto checkAccessControl = [&](AbstractFunctionDecl *func) {
-    if (!isABIPublic(original))
-      return false;
-    if (isABIPublic(func))
-      return false;
-    diags.diagnose(specifier.Loc, diag::differentiable_attr_invalid_access,
-                   specifier.Name, original->getFullName());
-    return true;
-  };
-
-  auto originalTypeCtx = original->getInnermostTypeContext();
-  if (!originalTypeCtx) originalTypeCtx = original->getParent();
-  assert(originalTypeCtx);
-
-  // Set lookup options.
-  auto lookupOptions = defaultMemberLookupOptions
-      | NameLookupFlags::IgnoreAccessControl;
-
-  auto *candidate = findAbstractFunctionDecl(
-      specifier.Name, specifier.Loc.getBaseNameLoc(), /*baseType*/ Type(),
-      originalTypeCtx, isValid, noneValidDiagnostic, ambiguousDiagnostic,
-      notFunctionDiagnostic, lookupOptions, hasValidTypeContext,
-      invalidTypeContextDiagnostic);
-  if (!candidate)
-    return nullptr;
-  // Reject non-`func` registered derivatives. JVPs and VJPs must be `func`
-  // declarations.
-  if (isa<AccessorDecl>(candidate)) {
-    diags.diagnose(specifier.Loc,
-                   diag::differentiable_attr_derivative_not_function,
-                   specifier.Name);
-    return nullptr;
-  }
-  if (checkAccessControl(candidate))
-    return nullptr;
-  // Derivatives of class members must be final.
-  if (original->getDeclContext()->getSelfClassDecl() &&
-      !candidate->isFinal()) {
-    diags.diagnose(specifier.Loc,
-                   diag::differentiable_attr_class_derivative_not_final);
-    return nullptr;
-  }
-  assert(isa<FuncDecl>(candidate));
-  auto *funcDecl = cast<FuncDecl>(candidate);
-  return funcDecl;
-}
-
-// SWIFT_ENABLE_TENSORFLOW
-void AttributeChecker::visitDifferentiableAttr(DifferentiableAttr *attr) {
-  // Call `getParameterIndices` to trigger a
-  // `DifferentiableAttributeParameterIndicesRequest`, which currently performs
-  // full `@differentiable` type-checking.
-  // TODO: Consider creating separate requests for the following functionality:
-  // - `DifferentiableAttr::getJVPFunction`
-  // - `DifferentiableAttr::getVJPFunction`
-  // - `DifferentiableAttr::getDerivativeGenericSignature`
-  (void)attr->getParameterIndices();
-}
-
 llvm::Expected<IndexSubset *>
 DifferentiableAttributeParameterIndicesRequest::evaluate(
     Evaluator &evaluator, DifferentiableAttr *attr, Decl *D) const {

lib/Sema/TypeCheckProtocol.h

@@ -358,15 +358,6 @@ struct RequirementMatch {
     assert(!hasWitnessType() && "Should have witness type");
   }
 
-  // SWIFT_ENABLE_TENSORFLOW
-  RequirementMatch(ValueDecl *witness, MatchKind kind,
-                   const DeclAttribute *attr)
-    : Witness(witness), Kind(kind), WitnessType(), UnmetAttribute(attr),
-      ReqEnv(None) {
-    assert(!hasWitnessType() && "Should have witness type");
-    assert(UnmetAttribute);
-  }
-
   RequirementMatch(ValueDecl *witness, MatchKind kind,
                    const DeclAttribute *attr)
       : Witness(witness), Kind(kind), WitnessType(), UnmetAttribute(attr),

lib/Serialization/Deserialization.cpp

@@ -4350,13 +4350,6 @@ llvm::Error DeclDeserializer::deserializeDeclAttributes() {
         break;
       }
 
-      case decls_block::ImplicitlySynthesizesNestedRequirement_DECL_ATTR: {
-        serialization::decls_block::ImplicitlySynthesizesNestedRequirementDeclAttrLayout
-            ::readRecord(scratch);
-        Attr = new (ctx) ImplicitlySynthesizesNestedRequirementAttr(blobData, {}, {});
-        break;
-      }
-
 #define SIMPLE_DECL_ATTR(NAME, CLASS, ...) \
       case decls_block::CLASS##_DECL_ATTR: { \
         bool isImplicit; \