AutoDiffIndexSubset -> IndexSubset

Author: dan-zheng

include/swift/AST/AutoDiff.h

@@ -243,8 +243,7 @@ class AutoDiffDerivativeFunctionIdentifier : public llvm::FoldingSetNode {
 /// derivative generic signature.
 // TODO(TF-893): Unify with `AutoDiffDerivativeFunctionIdentifier`.
 using SILDifferentiabilityWitnessKey =
-std::tuple<StringRef, AutoDiffIndexSubset *,
-           AutoDiffIndexSubset *, GenericSignature *>;
+    std::tuple<StringRef, IndexSubset *, IndexSubset *, GenericSignature *>;
 
 /// Automatic differentiation utility namespace.
 namespace autodiff {

include/swift/SIL/SILDifferentiabilityWitness.h

@@ -49,9 +49,9 @@ class SILDifferentiabilityWitness
   /// The original function.
   SILFunction *originalFunction;
   /// The parameter indices.
-  AutoDiffIndexSubset *parameterIndices;
+  IndexSubset *parameterIndices;
   /// The result indices.
-  AutoDiffIndexSubset *resultIndices;
+  IndexSubset *resultIndices;
   /// The derivative generic signature (optional).
   GenericSignature *derivativeGenericSignature;
   /// The JVP (Jacobian-vector products) derivative function.
@@ -64,8 +64,8 @@ class SILDifferentiabilityWitness
 
   SILDifferentiabilityWitness(SILModule &module, SILLinkage linkage,
                               SILFunction *originalFunction,
-                              AutoDiffIndexSubset *parameterIndices,
-                              AutoDiffIndexSubset *resultIndices,
+                              IndexSubset *parameterIndices,
+                              IndexSubset *resultIndices,
                               GenericSignature *derivativeGenSig,
                               SILFunction *jvp, SILFunction *vjp,
                               bool isSerialized)
@@ -77,18 +77,18 @@ class SILDifferentiabilityWitness
 public:
   static SILDifferentiabilityWitness *create(
       SILModule &module, SILLinkage linkage, SILFunction *originalFunction,
-      AutoDiffIndexSubset *parameterIndices, AutoDiffIndexSubset *resultIndices,
+      IndexSubset *parameterIndices, IndexSubset *resultIndices,
       GenericSignature *derivativeGenSig, SILFunction *jvp, SILFunction *vjp,
       bool isSerialized);
 
   SILDifferentiabilityWitnessKey getKey() const;
   SILModule &getModule() const { return module; }
   SILLinkage getLinkage() const { return linkage; }
   SILFunction *getOriginalFunction() const { return originalFunction; }
-  AutoDiffIndexSubset *getParameterIndices() const {
+  IndexSubset *getParameterIndices() const {
     return parameterIndices;
   }
-  AutoDiffIndexSubset *getResultIndices() const {
+  IndexSubset *getResultIndices() const {
     return resultIndices;
   }
   GenericSignature *getDerivativeGenericSignature() const {

lib/ParseSIL/ParseSIL.cpp

@@ -6860,8 +6860,8 @@ bool SILParserTUState::parseSILDifferentiabilityWitness(Parser &P) {
 
   SourceLoc lastLoc = P.getEndOfPreviousLoc();
   // Parse an index subset, prefaced with the given label.
-  auto parseAutoDiffIndexSubset =
-      [&](StringRef label, AutoDiffIndexSubset *& paramIndexSubset) -> bool {
+  auto parseIndexSubset =
+      [&](StringRef label, IndexSubset *& indexSubset) -> bool {
     if (P.parseSpecificIdentifier(
           label, diag::sil_diff_witness_expected_keyword, label))
       return true;
@@ -6892,16 +6892,16 @@ bool SILParserTUState::parseSILDifferentiabilityWitness(Parser &P) {
       return true;
     auto maxIndexRef =
         std::max_element(paramIndices.begin(), paramIndices.end());
-    paramIndexSubset = AutoDiffIndexSubset::get(
+    indexSubset = IndexSubset::get(
         P.Context, maxIndexRef ? *maxIndexRef + 1 : 0, paramIndices);
     return false;
   };
   // Parse parameter and result indices.
-  AutoDiffIndexSubset *parameterIndices = nullptr;
-  AutoDiffIndexSubset *resultIndices = nullptr;
-  if (parseAutoDiffIndexSubset("parameters", parameterIndices))
+  IndexSubset *parameterIndices = nullptr;
+  IndexSubset *resultIndices = nullptr;
+  if (parseIndexSubset("parameters", parameterIndices))
     return true;
-  if (parseAutoDiffIndexSubset("results", resultIndices))
+  if (parseIndexSubset("results", resultIndices))
     return true;
 
   // Parse a trailing 'where' clause (optional).

lib/SIL/SILDifferentiabilityWitness.cpp

@@ -19,7 +19,7 @@ using namespace swift;
 
 SILDifferentiabilityWitness *SILDifferentiabilityWitness::create(
     SILModule &module, SILLinkage linkage, SILFunction *originalFunction,
-    AutoDiffIndexSubset *parameterIndices, AutoDiffIndexSubset *resultIndices,
+    IndexSubset *parameterIndices, IndexSubset *resultIndices,
     GenericSignature *derivativeGenSig, SILFunction *jvp, SILFunction *vjp,
     bool isSerialized) {
   void *buf = module.allocate(sizeof(SILDifferentiabilityWitness),

lib/Serialization/DeserializeSIL.cpp

@@ -3346,11 +3346,11 @@ SILDeserializer::readDifferentiabilityWitness(DeclID DId) {
   assert(parameterAndResultIndices.size() ==
              numParameterIndices + numResultIndices &&
          "Parameter/result indices count mismatch");
-  auto *parameterIndices = AutoDiffIndexSubset::get(
+  auto *parameterIndices = IndexSubset::get(
       MF->getContext(), original->getLoweredFunctionType()->getNumParameters(),
       ArrayRef<unsigned>(parameterAndResultIndices)
           .take_front(numParameterIndices));
-  auto *resultIndices = AutoDiffIndexSubset::get(
+  auto *resultIndices = IndexSubset::get(
       MF->getContext(), original->getLoweredFunctionType()->getNumResults(),
       ArrayRef<unsigned>(parameterAndResultIndices)
           .take_back(numResultIndices));