Rename to 'IndexSubset' and move it to its own file.

Author: rxwei

include/swift/AST/ASTContext.h

@@ -109,7 +109,7 @@ namespace swift {
   class TypeAliasDecl;
   class VarDecl;
   class UnifiedStatsReporter;
-  class AutoDiffIndexSubset;
+  class IndexSubset;
 
   enum class KnownProtocolKind : uint8_t;
 

include/swift/AST/AutoDiff.h renamed to include/swift/AST/IndexSubset.h

@@ -1,4 +1,4 @@
-//===--- AutoDiff.h - Swift Differentiable Programming --------------------===//
+//===---------- IndexSubset.h - Fixed-size subset of indices --------------===//
 //
 // This source file is part of the Swift.org open source project
 //
@@ -10,24 +10,28 @@
 //
 //===----------------------------------------------------------------------===//
 //
-//  This file defines AST support for the experimental differentiable
-//  programming feature.
+// This file defines the `IndexSubset` class and support logic.
 //
 //===----------------------------------------------------------------------===//
 
+#ifndef SWIFT_AST_INDEXSUBSET_H
+#define SWIFT_AST_INDEXSUBSET_H
 
-#ifndef SWIFT_AST_AUTODIFF_H
-#define SWIFT_AST_AUTODIFF_H
-
-#include "ASTContext.h"
-#include "llvm/ADT/SmallBitVector.h"
+#include "swift/Basic/LLVM.h"
 #include "swift/Basic/Range.h"
+#include "swift/Basic/STLExtras.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/FoldingSet.h"
+#include "llvm/ADT/SmallBitVector.h"
+#include "llvm/Support/raw_ostream.h"
 
 namespace swift {
 
+class ASTContext;
+
 /// An efficient index subset data structure, uniqued in `ASTContext`.
 /// Stores a bit vector representing set indices and a total capacity.
-class AutoDiffIndexSubset : public llvm::FoldingSetNode {
+class IndexSubset : public llvm::FoldingSetNode {
 public:
   typedef uint64_t BitWord;
 
@@ -45,7 +49,7 @@ class AutoDiffIndexSubset : public llvm::FoldingSetNode {
     if (capacity == 0) return 0;
     return capacity / numBitsPerBitWord + 1;
   }
-  
+
 private:
   /// The total capacity of the index subset, which is `1` less than the largest
   /// index.
@@ -77,7 +81,7 @@ class AutoDiffIndexSubset : public llvm::FoldingSetNode {
     return {const_cast<BitWord *>(getBitWordsData()), getNumBitWords()};
   }
 
-  explicit AutoDiffIndexSubset(const SmallBitVector &indices)
+  explicit IndexSubset(const SmallBitVector &indices)
       : capacity((unsigned)indices.size()),
         numBitWords(getNumBitWordsNeededForCapacity(capacity)) {
     std::uninitialized_fill_n(getBitWordsData(), numBitWords, 0);
@@ -89,39 +93,38 @@ class AutoDiffIndexSubset : public llvm::FoldingSetNode {
   }
 
 public:
-  AutoDiffIndexSubset() = delete;
-  AutoDiffIndexSubset(const AutoDiffIndexSubset &) = delete;
-  AutoDiffIndexSubset &operator=(const AutoDiffIndexSubset &) = delete;
+  IndexSubset() = delete;
+  IndexSubset(const IndexSubset &) = delete;
+  IndexSubset &operator=(const IndexSubset &) = delete;
 
   // Defined in ASTContext.cpp.
-  static AutoDiffIndexSubset *get(ASTContext &ctx,
-                                  const SmallBitVector &indices);
+  static IndexSubset *get(ASTContext &ctx, const SmallBitVector &indices);
 
-  static AutoDiffIndexSubset *get(ASTContext &ctx, unsigned capacity,
-                                  ArrayRef<unsigned> indices) {
+  static IndexSubset *get(ASTContext &ctx, unsigned capacity,
+                          ArrayRef<unsigned> indices) {
     SmallBitVector indicesBitVec(capacity, false);
     for (auto index : indices)
       indicesBitVec.set(index);
-    return AutoDiffIndexSubset::get(ctx, indicesBitVec);
+    return IndexSubset::get(ctx, indicesBitVec);
   }
 
-  static AutoDiffIndexSubset *getDefault(ASTContext &ctx, unsigned capacity,
-                                         bool includeAll = false) {
+  static IndexSubset *getDefault(ASTContext &ctx, unsigned capacity,
+                                 bool includeAll = false) {
     return get(ctx, SmallBitVector(capacity, includeAll));
   }
 
-  static AutoDiffIndexSubset *getFromRange(ASTContext &ctx, unsigned capacity,
-                                           unsigned start, unsigned end) {
+  static IndexSubset *getFromRange(ASTContext &ctx, unsigned capacity,
+                                   unsigned start, unsigned end) {
     assert(start < capacity);
     assert(end <= capacity);
     SmallBitVector bitVec(capacity);
     bitVec.set(start, end);
     return get(ctx, bitVec);
   }
-  
+
   /// Creates an index subset corresponding to the given string generated by
   /// `getString()`. If the string is invalid, returns nullptr.
-  static AutoDiffIndexSubset *getFromString(ASTContext &ctx, StringRef string);
+  static IndexSubset *getFromString(ASTContext &ctx, StringRef string);
 
   /// Returns the number of bit words used to store the index subset.
   // Note: Use `getCapacity()` to get the total index subset capacity.
@@ -148,11 +151,11 @@ class AutoDiffIndexSubset : public llvm::FoldingSetNode {
   iterator begin() const {
     return iterator(this);
   }
-  
+
   iterator end() const {
     return iterator(this, (int)capacity);
   }
-  
+
   /// Returns an iterator range of indices in the index subset.
   iterator_range<iterator> getIndices() const {
     return make_range(begin(), end());
@@ -162,7 +165,7 @@ class AutoDiffIndexSubset : public llvm::FoldingSetNode {
   unsigned getNumIndices() const {
     return (unsigned)std::distance(begin(), end());
   }
-  
+
   SmallBitVector getBitVector() const {
     SmallBitVector indicesBitVec(capacity, false);
     for (auto index : getIndices())
@@ -179,18 +182,18 @@ class AutoDiffIndexSubset : public llvm::FoldingSetNode {
   bool isEmpty() const {
     return llvm::all_of(getBitWords(), [](BitWord bw) { return !(bool)bw; });
   }
-  
-  bool equals(AutoDiffIndexSubset *other) const {
+
+  bool equals(IndexSubset *other) const {
     return capacity == other->getCapacity() &&
-        getBitWords().equals(other->getBitWords());
+    getBitWords().equals(other->getBitWords());
   }
 
-  bool isSubsetOf(AutoDiffIndexSubset *other) const;
-  bool isSupersetOf(AutoDiffIndexSubset *other) const;
+  bool isSubsetOf(IndexSubset *other) const;
+  bool isSupersetOf(IndexSubset *other) const;
 
-  AutoDiffIndexSubset *adding(unsigned index, ASTContext &ctx) const;
-  AutoDiffIndexSubset *extendingCapacity(ASTContext &ctx,
-                                         unsigned newCapacity) const;
+  IndexSubset *adding(unsigned index, ASTContext &ctx) const;
+  IndexSubset *extendingCapacity(ASTContext &ctx,
+                                 unsigned newCapacity) const;
 
   void Profile(llvm::FoldingSetNodeID &id) const {
     id.AddInteger(capacity);
@@ -206,7 +209,7 @@ class AutoDiffIndexSubset : public llvm::FoldingSetNode {
   }
 
   void dump(llvm::raw_ostream &s = llvm::errs()) const {
-    s << "(autodiff_index_subset capacity=" << capacity << " indices=(";
+    s << "(index_subset capacity=" << capacity << " indices=(";
     interleave(getIndices(), [&s](unsigned i) { s << i; },
                [&s] { s << ", "; });
     s << "))";
@@ -226,7 +229,7 @@ class AutoDiffIndexSubset : public llvm::FoldingSetNode {
     typedef std::forward_iterator_tag iterator_category;
 
   private:
-    const AutoDiffIndexSubset *parent;
+    const IndexSubset *parent;
     int current = 0;
 
     void advance() {
@@ -235,10 +238,10 @@ class AutoDiffIndexSubset : public llvm::FoldingSetNode {
     }
 
   public:
-    iterator(const AutoDiffIndexSubset *parent, int current)
-        : parent(parent), current(current) {}
-    explicit iterator(const AutoDiffIndexSubset *parent)
-        : iterator(parent, parent->findFirst()) {}
+    iterator(const IndexSubset *parent, int current)
+    : parent(parent), current(current) {}
+    explicit iterator(const IndexSubset *parent)
+    : iterator(parent, parent->findFirst()) {}
     iterator(const iterator &) = default;
 
     iterator operator++(int) {
@@ -256,18 +259,18 @@ class AutoDiffIndexSubset : public llvm::FoldingSetNode {
 
     bool operator==(const iterator &other) const {
       assert(parent == other.parent &&
-             "Comparing iterators from different AutoDiffIndexSubsets");
+             "Comparing iterators from different IndexSubsets");
       return current == other.current;
     }
 
     bool operator!=(const iterator &other) const {
       assert(parent == other.parent &&
-             "Comparing iterators from different AutoDiffIndexSubsets");
+             "Comparing iterators from different IndexSubsets");
       return current != other.current;
     }
   };
 };
 
-} // end namespace swift
+}
 
-#endif // SWIFT_AST_AUTODIFF_H
+#endif // SWIFT_AST_INDEXSUBSET_H

lib/AST/ASTContext.cpp

@@ -428,8 +428,8 @@ FOR_KNOWN_FOUNDATION_TYPES(CACHE_FOUNDATION_DECL)
   llvm::FoldingSet<DeclName::CompoundDeclName> CompoundNames;
   llvm::DenseMap<UUID, OpenedArchetypeType *> OpenedExistentialArchetypes;
 
-  /// For uniquifying `AutoDiffIndexSubset` allocations.
-  llvm::FoldingSet<AutoDiffIndexSubset> AutoDiffIndexSubsets;
+  /// For uniquifying `IndexSubset` allocations.
+  llvm::FoldingSet<IndexSubset> IndexSubsets;
 
   /// A cache of information about whether particular nominal types
   /// are representable in a foreign language.
@@ -4621,9 +4621,9 @@ void VarDecl::setOriginalWrappedProperty(VarDecl *originalProperty) {
   ctx.getImpl().OriginalWrappedProperties[this] = originalProperty;
 }
 
-AutoDiffIndexSubset *
-AutoDiffIndexSubset::get(ASTContext &ctx, const SmallBitVector &indices) {
-  auto &foldingSet = ctx.getImpl().AutoDiffIndexSubsets;
+IndexSubset *
+IndexSubset::get(ASTContext &ctx, const SmallBitVector &indices) {
+  auto &foldingSet = ctx.getImpl().IndexSubsets;
   llvm::FoldingSetNodeID id;
   unsigned capacity = indices.size();
   id.AddInteger(capacity);
@@ -4633,11 +4633,11 @@ AutoDiffIndexSubset::get(ASTContext &ctx, const SmallBitVector &indices) {
   auto *existing = foldingSet.FindNodeOrInsertPos(id, insertPos);
   if (existing)
     return existing;
-  auto sizeToAlloc = sizeof(AutoDiffIndexSubset) +
+  auto sizeToAlloc = sizeof(IndexSubset) +
     getNumBitWordsNeededForCapacity(capacity);
-  auto *buf = reinterpret_cast<AutoDiffIndexSubset *>(
-    ctx.Allocate(sizeToAlloc, alignof(AutoDiffIndexSubset)));
-  auto *newNode = new (buf) AutoDiffIndexSubset(indices);
+  auto *buf = reinterpret_cast<IndexSubset *>(
+    ctx.Allocate(sizeToAlloc, alignof(IndexSubset)));
+  auto *newNode = new (buf) IndexSubset(indices);
   foldingSet.InsertNode(newNode, insertPos);
   return newNode;
 }

lib/AST/CMakeLists.txt

@@ -29,7 +29,7 @@ add_swift_host_library(swiftAST STATIC
   ASTVerifier.cpp
   ASTWalker.cpp
   Attr.cpp
-  AutoDiff.cpp
+  IndexSubset.cpp
   Availability.cpp
   AvailabilitySpec.cpp
   Builtins.cpp

lib/AST/AutoDiff.cpp renamed to lib/AST/IndexSubset.cpp

@@ -1,28 +1,21 @@
-//===--- AutoDiff.cpp - Swift Differentiable Programming ------------------===//
+//===-------- IndexSubset.cpp - Swift Differentiable Programming ----------===//
 //
 // This source file is part of the Swift.org open source project
 //
-// Copyright (c) 2014 - 2019 Apple Inc. and the Swift project authors
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
 // Licensed under Apache License v2.0 with Runtime Library Exception
 //
 // See https://swift.org/LICENSE.txt for license information
 // See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 //
 //===----------------------------------------------------------------------===//
 
-#include "swift/AST/AutoDiff.h"
-#include "swift/AST/Module.h"
-#include "swift/AST/Types.h"
-#include "swift/SIL/SILLinkage.h"
-#include "swift/Basic/LLVM.h"
-#include "swift/Basic/Range.h"
-#include "llvm/ADT/STLExtras.h"
-#include "llvm/ADT/StringSwitch.h"
+#include "swift/AST/IndexSubset.h"
 
 using namespace swift;
 
-AutoDiffIndexSubset *
-AutoDiffIndexSubset::getFromString(ASTContext &ctx, StringRef string) {
+IndexSubset *
+IndexSubset::getFromString(ASTContext &ctx, StringRef string) {
   if (string.size() < 0) return nullptr;
   unsigned capacity = string.size();
   llvm::SmallBitVector indices(capacity);
@@ -35,35 +28,34 @@ AutoDiffIndexSubset::getFromString(ASTContext &ctx, StringRef string) {
   return get(ctx, indices);
 }
 
-std::string AutoDiffIndexSubset::getString() const {
+std::string IndexSubset::getString() const {
   std::string result;
   result.reserve(capacity);
   for (unsigned i : range(capacity))
     result += contains(i) ? 'S' : 'U';
   return result;
 }
 
-bool AutoDiffIndexSubset::isSubsetOf(AutoDiffIndexSubset *other) const {
+bool IndexSubset::isSubsetOf(IndexSubset *other) const {
   assert(capacity == other->capacity);
   for (auto index : range(numBitWords))
     if (getBitWord(index) & ~other->getBitWord(index))
       return false;
   return true;
 }
 
-bool AutoDiffIndexSubset::isSupersetOf(AutoDiffIndexSubset *other) const {
+bool IndexSubset::isSupersetOf(IndexSubset *other) const {
   assert(capacity == other->capacity);
   for (auto index : range(numBitWords))
     if (~getBitWord(index) & other->getBitWord(index))
       return false;
   return true;
 }
 
-AutoDiffIndexSubset *AutoDiffIndexSubset::adding(unsigned index,
-                                                 ASTContext &ctx) const {
+IndexSubset *IndexSubset::adding(unsigned index, ASTContext &ctx) const {
   assert(index < getCapacity());
   if (contains(index))
-    return const_cast<AutoDiffIndexSubset *>(this);
+    return const_cast<IndexSubset *>(this);
   SmallBitVector newIndices(capacity);
   bool inserted = false;
   for (auto curIndex : getIndices()) {
@@ -76,18 +68,18 @@ AutoDiffIndexSubset *AutoDiffIndexSubset::adding(unsigned index,
   return get(ctx, newIndices);
 }
 
-AutoDiffIndexSubset *AutoDiffIndexSubset::extendingCapacity(
+IndexSubset *IndexSubset::extendingCapacity(
     ASTContext &ctx, unsigned newCapacity) const {
   assert(newCapacity >= capacity);
   if (newCapacity == capacity)
-    return const_cast<AutoDiffIndexSubset *>(this);
+    return const_cast<IndexSubset *>(this);
   SmallBitVector indices(newCapacity);
   for (auto index : getIndices())
     indices.set(index);
-  return AutoDiffIndexSubset::get(ctx, indices);
+  return IndexSubset::get(ctx, indices);
 }
 
-int AutoDiffIndexSubset::findNext(int startIndex) const {
+int IndexSubset::findNext(int startIndex) const {
   assert(startIndex < (int)capacity && "Start index cannot be past the end");
   unsigned bitWordIndex = 0, offset = 0;
   if (startIndex >= 0) {
@@ -110,7 +102,7 @@ int AutoDiffIndexSubset::findNext(int startIndex) const {
   return capacity;
 }
 
-int AutoDiffIndexSubset::findPrevious(int endIndex) const {
+int IndexSubset::findPrevious(int endIndex) const {
   assert(endIndex >= 0 && "End index cannot be before the start");
   int bitWordIndex = numBitWords - 1, offset = numBitsPerBitWord - 1;
   if (endIndex < (int)capacity) {