Rename "associated function" to "derivative function".

Author: rxwei

include/swift/AST/ASTMangler.h

@@ -155,9 +155,9 @@ class ASTMangler : public Mangler {
                                              ModuleDecl *Module);
 
   // SWIFT_ENABLE_TENSORFLOW
-  // Mangle the autodiff associated function (JVP/VJP) with the given:
+  // Mangle the derivative function (JVP/VJP) with the given:
   // - Mangled original function name.
-  // - Associated function kind.
+  // - Derivative function kind.
   // - Parameter/result indices.
   std::string mangleAutoDiffDerivativeFunctionHelper(
       StringRef name, AutoDiffDerivativeFunctionKind kind,

include/swift/AST/AutoDiff.h

@@ -431,7 +431,7 @@ struct AutoDiffLinearMapKind {
   operator innerty() const { return rawValue; }
 };
 
-/// The kind of an associated function.
+/// The kind of an derivative function.
 struct AutoDiffDerivativeFunctionKind {
   enum innerty : uint8_t {
    // The Jacobian-vector products function.
@@ -452,7 +452,7 @@ struct AutoDiffDerivativeFunctionKind {
 };
 
 /// In conjunction with the original function declaration, identifies an
-/// autodiff associated function.
+/// autodiff derivative function.
 ///
 /// Is uniquely allocated within an ASTContext so that it can be hashed and
 /// compared by opaque pointer value.
@@ -523,7 +523,7 @@ bool getBuiltinAutoDiffApplyConfig(StringRef operationName,
                                    AutoDiffDerivativeFunctionKind &kind,
                                    unsigned &arity, bool &rethrows);
 
-/// Computes the correct linkage for an associated function given the linkage of
+/// Computes the correct linkage for an derivative function given the linkage of
 /// the original function. If the original linkage is not external and
 /// `isDerivativeFnExported` is true, use the original function's linkage. Otherwise,
 /// return hidden linkage.

include/swift/AST/DiagnosticsParse.def

@@ -1597,15 +1597,15 @@ ERROR(sil_inst_autodiff_attr_expected_rsquare,PointsToFirstBadToken,
 ERROR(sil_inst_autodiff_expected_parameter_index,PointsToFirstBadToken,
       "expected the index of a parameter to differentiate with respect to", ())
 ERROR(sil_inst_autodiff_operand_list_expected_lbrace,PointsToFirstBadToken,
-      "expected '{' to start an associated function list", ())
+      "expected '{' to start an derivative function list", ())
 ERROR(sil_inst_autodiff_operand_list_expected_comma,PointsToFirstBadToken,
-      "expected ',' between operands in an associated function list", ())
+      "expected ',' between operands in an derivative function list", ())
 ERROR(sil_inst_autodiff_operand_list_expected_rbrace,PointsToFirstBadToken,
-      "expected '}' to start an associated function list", ())
+      "expected '}' to start an derivative function list", ())
 ERROR(sil_inst_autodiff_num_operand_list_order_mismatch,PointsToFirstBadToken,
       "the number of operand lists does not match the order", ())
 ERROR(sil_inst_autodiff_expected_associated_function_kind_attr,PointsToFirstBadToken,
-      "expected an associated function kind attribute, e.g. '[jvp]'", ())
+      "expected an derivative function kind attribute, e.g. '[jvp]'", ())
 ERROR(sil_inst_autodiff_expected_function_type_operand,PointsToFirstBadToken,
       "expected an operand of a function type", ())
 

include/swift/AST/Types.h

@@ -3100,10 +3100,10 @@ class AnyFunctionType : public TypeBase {
 
   // SWIFT_ENABLE_TENSORFLOW
   /// Given `indices` and `kind`, calculates the type of the corresponding
-  /// autodiff associated function.
+  /// autodiff derivative function.
   ///
   /// By default, if the original type has a self parameter list and parameter
-  /// indices include self, the computed associated function type will return a
+  /// indices include self, the computed derivative function type will return a
   /// linear map taking/returning self's tangent *last* instead of first, for
   /// consistency with SIL.
   ///
@@ -3121,11 +3121,11 @@ class AnyFunctionType : public TypeBase {
       GenericSignature *whereClauseGenericSignature = nullptr,
       bool makeSelfParamFirst = false);
 
-  /// Given the type of an autodiff associated function, returns the
+  /// Given the type of an autodiff derivative function, returns the
   /// corresponding original function type.
   AnyFunctionType *getAutoDiffOriginalFunctionType();
 
-  /// Given the type of a transposing associated function, returns the
+  /// Given the type of a transposing derivative function, returns the
   /// corresponding original function type.
   AnyFunctionType *
   getTransposeOriginalFunctionType(TransposingAttr *attr,

include/swift/SIL/SILDeclRef.h

@@ -157,7 +157,7 @@ struct SILDeclRef {
 
   // SWIFT_ENABLE_TENSORFLOW
   /// When this is non-null, it modifies the SILDeclRef to refer to the
-  /// corresponding autodiff associated function.
+  /// corresponding autodiff derivative function.
   AutoDiffDerivativeFunctionIdentifier *autoDiffDerivativeFunctionIdentifier;
 
   /// Produces a null SILDeclRef.
@@ -363,7 +363,7 @@ struct SILDeclRef {
   }
 
   /// Returns the entry point for the original function corresponding to an
-  /// autodiff associated function.
+  /// autodiff derivative function.
   SILDeclRef asAutoDiffOriginalFunction() const {
     assert(autoDiffDerivativeFunctionIdentifier);
     SILDeclRef r = *this;

include/swift/SILOptimizer/Analysis/BottomUpIPAnalysis.h

@@ -43,7 +43,7 @@ class BottomUpIPAnalysis : public SILAnalysis {
   /// analysis information for a function.
   /// This base class stores the administrative information needed for
   /// invalidation and updating the analysis.
-  /// In the following "this function" refers to the associated function.
+  /// In the following "this function" refers to the derivative function.
   template<typename FunctionInfo> class FunctionInfoBase {
   public:
 

lib/AST/Attr.cpp

@@ -520,7 +520,7 @@ static void printDifferentiableAttrArguments(
       stream << diffParamsString;
     }
   }
-  // Print associated function names, unless they are to be omitted.
+  // Print derivative function names, unless they are to be omitted.
   if (!omitDerivativeFunctions) {
     // Print jvp function name, if specified.
     if (auto jvp = attr->getJVP()) {

lib/AST/Builtins.cpp

@@ -1035,14 +1035,14 @@ static ValueDecl *getAutoDiffApplyDerivativeFunction(
     }
   };
   // Eagerly build the type of the first arg, then use that to compute the type
-  // of the associated function type.
+  // of the derivative function type.
   auto *origFnTy =
       firstArgGen.build(builder)->castTo<AnyFunctionType>();
   origFnTy = origFnTy->getWithoutDifferentiability()->withExtInfo(
       origFnTy->getExtInfo().withNoEscape(false));
   auto *paramIndices = AutoDiffIndexSubset::get(
       Context, SmallBitVector(origFnTy->getNumParams(), true));
-  // Generator for the resultant function type, i.e. the AD associated function.
+  // Generator for the resultant function type, i.e. the AD derivative function.
   BuiltinGenericSignatureBuilder::LambdaGenerator resultGen{
       [=, &Context](BuiltinGenericSignatureBuilder &builder) -> Type {
         auto derivativeFnTy = origFnTy->getAutoDiffDerivativeFunctionType(

lib/AST/Type.cpp

@@ -4677,7 +4677,7 @@ AnyFunctionType *AnyFunctionType::getAutoDiffDerivativeFunctionType(
       curryLevels.back(), curryLevels.back()->getParams(), retTy,
       curryLevels.size() == 1 ? whereClauseGenSig : nullptr);
 
-  // Wrap the associated function type in additional curry levels.
+  // Wrap the derivative function type in additional curry levels.
   auto curryLevelsWithoutLast =
       ArrayRef<AnyFunctionType *>(curryLevels).drop_back(1);
   for (auto pair : enumerate(reversed(curryLevelsWithoutLast))) {
@@ -4716,7 +4716,7 @@ AnyFunctionType::getAutoDiffOriginalFunctionType() {
       curryLevels.back(), curryLevels.back()->getParams(), originalResult,
       curryLevels.size() == 1 ? getOptGenericSignature() : nullptr);
 
-  // Wrap the associated function type in additional curry levels.
+  // Wrap the derivative function type in additional curry levels.
   auto curryLevelsWithoutLast =
       ArrayRef<AnyFunctionType *>(curryLevels).drop_back(1);
   for (auto pair : enumerate(reversed(curryLevelsWithoutLast))) {

lib/ParseSIL/ParseSIL.cpp

@@ -2960,9 +2960,9 @@ bool SILParser::parseSILInstruction(SILBuilder &B) {
     // Parse an optional operand list `with { <operand> , <operand> }`.
     if (P.Tok.is(tok::identifier) && P.Tok.getText() == "with") {
       P.consumeToken(tok::identifier);
-      // Parse associated function values as an operand list.
+      // Parse derivative function values as an operand list.
       // FIXME(rxwei): Change this to *not* require a type signature once
-      // we can infer AD associated function types.
+      // we can infer derivative function types.
       SILValue derivFn1, derivFn2;
       if (P.parseToken(tok::l_brace,
               diag::sil_inst_autodiff_operand_list_expected_lbrace) ||
@@ -3003,7 +3003,7 @@ bool SILParser::parseSILInstruction(SILBuilder &B) {
             diag::sil_inst_autodiff_expected_associated_function_kind_attr) ||
         P.parseToken(tok::r_square,
                      diag::sil_inst_autodiff_attr_expected_rsquare,
-                     "associated function kind"))
+                     "derivative function kind"))
       return true;
     if (parseTypedValueRef(functionOperand, B) ||
         parseSILDebugLocation(InstLoc, B))

lib/SILGen/SILGen.h

@@ -148,15 +148,15 @@ class LLVM_LIBRARY_VISIBILITY SILGenModule : public ASTVisitor<SILGenModule> {
                                CanSILFunctionType constantTy);
 
   // SWIFT_ENABLE_TENSORFLOW
-  /// Get or create an autodiff associated function thunk for the given
-  /// SILDeclRef, SILFunction, and associated function type.
+  /// Get or create an autodiff derivative function thunk for the given
+  /// SILDeclRef, SILFunction, and derivative function type.
   SILFunction *getOrCreateAutoDiffThunk(SILDeclRef derivativeFnRef,
                                         SILFunction *derivativeFn,
                                         CanSILFunctionType derivativeFnTy);
 
   // SWIFT_ENABLE_TENSORFLOW
-  /// Get or create an autodiff associated function vtable entry thunk for the
-  /// given SILDeclRef and associated function type.
+  /// Get or create an autodiff derivative function vtable entry thunk for the
+  /// given SILDeclRef and derivative function type.
   SILFunction *
   getOrCreateAutoDiffClassMethodThunk(SILDeclRef derivativeFnRef,
                                       CanSILFunctionType derivativeFnTy);

lib/SILGen/SILGenBuiltin.cpp

@@ -1040,7 +1040,7 @@ static ManagedValue emitBuiltinAutoDiffApplyDerivativeFunction(
   for (auto& arg : args.drop_front(1))
     origFnArgVals.push_back(arg.getValue());
 
-  // Get the associated function.
+  // Get the derivative function.
   SILValue derivativeFn = SGF.B.createDifferentiableFunctionExtract(
       loc, kind, origFnVal);
   auto derivativeFnType = derivativeFn->getType().castTo<SILFunctionType>();

lib/SILOptimizer/Mandatory/Differentiation.cpp

@@ -878,7 +878,7 @@ class ADContext {
   /// Saved for deletion during cleanup.
   SmallVector<SILFunction *, 32> generatedFunctions;
 
-  /// List of associated function references, generated via
+  /// List of derivative function references, generated via
   /// `emitDerivativeFunctionReference`.
   /// Saved for deletion during cleanup.
   SmallVector<SILValue, 32> generatedDerivativeFunctionReferences;
@@ -1131,7 +1131,7 @@ class ADContext {
       DifferentiationInvoker invoker);
 
   /// Process the given `differentiable_function` instruction, filling in
-  /// missing associated functions if necessary.
+  /// missing derivative functions if necessary.
   bool processDifferentiableFunctionInst(DifferentiableFunctionInst *dfi);
 
   /// Fold `differentiable_function_extract` users of the given
@@ -1145,27 +1145,27 @@ class ADContext {
   /// purposes.
   void foldDifferentiableFunctionExtraction(DifferentiableFunctionInst *source);
 
-  /// Get or create an associated function index subset thunk from
-  /// `actualIndices` to `desiredIndices` for the given associated function
+  /// Get or create an derivative function index subset thunk from
+  /// `actualIndices` to `desiredIndices` for the given derivative function
   /// value and original function operand.
   /// Calls `getOrCreateSubsetParametersThunkForLinearMap` to thunk the linear
-  /// map returned by the associated function.
+  /// map returned by the derivative function.
   std::pair<SILFunction *, SubstitutionMap>
   getOrCreateSubsetParametersThunkForDerivativeFunction(
       SILValue origFnOperand, SILValue assocFn,
       AutoDiffDerivativeFunctionKind kind, SILAutoDiffIndices desiredIndices,
       SILAutoDiffIndices actualIndices);
 
-  /// Get or create an associated function index subset thunk from
-  /// `actualIndices` to `desiredIndices` for the given associated function
+  /// Get or create an derivative function index subset thunk from
+  /// `actualIndices` to `desiredIndices` for the given derivative function
   /// value and original function operand.
   SILFunction *getOrCreateSubsetParametersThunkForLinearMap(
       SILFunction *assocFn, CanSILFunctionType linearMapType,
       CanSILFunctionType targetType, AutoDiffDerivativeFunctionKind kind,
       SILAutoDiffIndices desiredIndices, SILAutoDiffIndices actualIndices);
 
 public:
-  /// Declare an external reference to an associated function of `original`,
+  /// Declare an external reference to an derivative function of `original`,
   /// given a `[differentiable]` attribute of `original` and the associated
   /// function kind.
   SILFunction *
@@ -1705,7 +1705,7 @@ void LinearMapInfo::generateDifferentiationDataStructures(
   auto *loopAnalysis = context.getPassManager().getAnalysis<SILLoopAnalysis>();
   auto *loopInfo = loopAnalysis->get(original);
 
-  // Get the associated function generic signature.
+  // Get the derivative function generic signature.
   CanGenericSignature assocFnGenSig = nullptr;
   if (auto *assocFnGenEnv = assocFn->getGenericEnvironment())
     assocFnGenSig =
@@ -2530,9 +2530,9 @@ static SubstitutionMap getSubstitutionMap(
   return substMap;
 }
 
-/// Emits a reference to an associated function of `original`, differentiated
+/// Emits a reference to an derivative function of `original`, differentiated
 /// with respect to a superset of `desiredIndices`. Returns the `SILValue` for
-/// the associated function and the actual indices that the associated function
+/// the derivative function and the actual indices that the derivative function
 /// is with respect to.
 ///
 /// Returns `None` on failure, signifying that a diagnostic has been emitted.
@@ -2554,15 +2554,15 @@ emitDerivativeFunctionReference(
 
   // If `original` is itself an `DifferentiableFunctionExtractInst` whose kind matches
   // the given kind and desired differentiation parameter indices, simply
-  // extract the associated function of its function operand, retain the
-  // associated function, and return it.
+  // extract the derivative function of its function operand, retain the
+  // derivative function, and return it.
   if (auto *inst = original->getDefiningInstruction())
     if (auto *dfei = dyn_cast<DifferentiableFunctionExtractInst>(inst))
       if (dfei->getExtractee() == DifferentiableFunctionExtractee::Original)
         functionSource = dfei->getFunctionOperand();
 
   // If `functionSource` is a `@differentiable` function, just extract the
-  // associated function.
+  // derivative function.
   if (auto diffableFnType =
           functionSource->getType().castTo<SILFunctionType>()) {
     if (diffableFnType->isDifferentiable()) {
@@ -2711,7 +2711,7 @@ emitDerivativeFunctionReference(
           diag::autodiff_member_subset_indices_not_differentiable);
       return None;
     }
-    // Emit a `witness_method` instruction for the associated function.
+    // Emit a `witness_method` instruction for the derivative function.
     auto originalType = witnessMethod->getType().castTo<SILFunctionType>();
     auto assocType = originalType->getAutoDiffDerivativeFunctionType(
         minimalIndices.parameters, minimalIndices.source,
@@ -2758,7 +2758,7 @@ emitDerivativeFunctionReference(
           diag::autodiff_member_subset_indices_not_differentiable);
       return None;
     }
-    // Emit a `class_method` instruction for the associated function.
+    // Emit a `class_method` instruction for the derivative function.
     auto originalType = classMethodInst->getType().castTo<SILFunctionType>();
     auto assocType = originalType->getAutoDiffDerivativeFunctionType(
         minimalIndices.parameters, minimalIndices.source,
@@ -7980,7 +7980,7 @@ bool ADContext::processDifferentiableAttribute(
     attr->setJVPName(jvpName);
   }
 
-  // If differentiation is triggered by `[differentiable]`, associated function
+  // If differentiation is triggered by `[differentiable]`, derivative function
   // should share linkage of original function.
   auto isAssocFnExported =
       invoker.getKind() ==
@@ -8334,7 +8334,7 @@ ADContext::getOrCreateSubsetParametersThunkForDerivativeFunction(
     AutoDiffDerivativeFunctionKind kind, SILAutoDiffIndices desiredIndices,
     SILAutoDiffIndices actualIndices) {
   LLVM_DEBUG(getADDebugStream()
-             << "Getting a subset parameters thunk for associated function "
+             << "Getting a subset parameters thunk for derivative function "
              << assocFn << " of the original function " << origFnOperand
              << " from " << actualIndices << " to " << desiredIndices << '\n');
 
@@ -8441,7 +8441,7 @@ ADContext::getOrCreateSubsetParametersThunkForDerivativeFunction(
         loc, classOperand, assocMethodInst->getMember(),
         thunk->mapTypeIntoContext(assocMethodInst->getType()));
   }
-  assert(assocRef && "Expected associated function to be resolved");
+  assert(assocRef && "Expected derivative function to be resolved");
 
   assocSubstMap = assocSubstMap.subst(thunk->getForwardingSubstitutionMap());
   assocFnType = assocRef->getType().castTo<SILFunctionType>();
@@ -8592,7 +8592,7 @@ SILValue ADContext::promoteToDifferentiableFunction(
     getGeneratedDerivativeFunctionReferences().push_back(assocFn);
 
     // If desired indices are a subset of actual indices, create a "subset
-    // indices thunk" and destroy the emitted associated function reference.
+    // indices thunk" and destroy the emitted derivative function reference.
     // - For JVPs: the thunked JVP returns a differential taking fewer
     //   parameters (using `.zero` for the dropped parameters).
     // - For VJPs: the thunked VJP returns a pullback that drops the unused
@@ -8606,7 +8606,7 @@ SILValue ADContext::promoteToDifferentiableFunction(
         getASTContext(), actualIndices.parameters->getCapacity());
     if (actualIndices.source != desiredIndices.source ||
         !actualIndices.parameters->equals(extendedDesiredIndices)) {
-      // Destroy the already emitted associated function reference because it
+      // Destroy the already emitted derivative function reference because it
       // is no longer used.
       builder.emitDestroyValueOperation(loc, assocFn);
       // Check if underlying original function reference has been partially
@@ -8661,7 +8661,7 @@ SILValue ADContext::promoteToDifferentiableFunction(
 
     assocFns.push_back(assocFn);
   }
-  // Deallocate temporary buffers used for creating associated functions.
+  // Deallocate temporary buffers used for creating derivative functions.
   for (auto *buf : reversed(newBuffersToDealloc))
     builder.createDeallocStack(loc, buf);
 
@@ -8701,7 +8701,7 @@ void ADContext::foldDifferentiableFunctionExtraction(
       dfei->eraseFromParent();
       continue;
     }
-    // Fold associated function extractors.
+    // Fold derivative function extractors.
     auto assocFnValue =
         source->getDerivativeFunction(dfei->getDerivativeFunctionKind());
     dfei->replaceAllUsesWith(assocFnValue);

lib/Sema/MiscDiagnostics.cpp

@@ -2248,7 +2248,7 @@ class VarDeclUsageChecker : public ASTWalker {
 };
 
 /// An AST walker that determines the underlying type of an opaque return decl
-/// from its associated function body.
+/// from its derivative function body.
 class OpaqueUnderlyingTypeChecker : public ASTWalker {
   TypeChecker &TC;
   AbstractFunctionDecl *Implementation;