Rename IntList to IntArrayRef. (pytorch#16751)

Summary:
Pull Request resolved: pytorch#16751

This was made more complicated by the fact that ivalue::IntList
is a thing.  So I had to fix all of the sites where we referring
to IValue post facto.

The following codemods were run, in this order:

```
codemod -m -d . --extensions cc,cpp,cu,cuh,h,hpp,py,cwrap,yaml,in IntList IntArrayRef
codemod -m -d . --extensions cc,cpp,cu,cuh,h,hpp,py,cwrap,yaml,in IntArrayRef::create IntList::create
codemod -m -d . --extensions cc,cpp,cu,cuh,h,hpp,py,cwrap,yaml,in ivalue::IntArrayRef ivalue::IntList
codemod -m -d . --extensions cc,cpp,cu,cuh,h,hpp,py,cwrap,yaml,in Tag::IntArrayRef Tag::IntList
codemod -m -d . --extensions cc,cpp,cu,cuh,h,hpp,py,cwrap,yaml,in isIntArrayRef isIntList
codemod -m -d . --extensions cc,cpp,cu,cuh,h,hpp,py,cwrap,yaml,in toIntArrayRef toIntList
codemod -m -d . --extensions cc,cpp,cu,cuh,h,hpp,py,cwrap,yaml,in 'Shared<IntArrayRef>' 'Shared<IntList>'
codemod -m -d . --extensions cc,cpp,cu,cuh,h,hpp,py,cwrap,yaml,in 'intrusive_ptr<IntArrayRef>' 'intrusive_ptr<IntList>'
```

Some manual fixups were done afterwards; they can be reviewed separately
at pytorch#16752

Reviewed By: dzhulgakov

Differential Revision: D13954363

fbshipit-source-id: b5c40aacba042402155a2f5a229fa6db7992ac64

Author: ezyang

aten/src/ATen/CPUApplyUtils.h

@@ -127,7 +127,7 @@ inline std::pair<int64_t, int64_t> collapse_dims(
  */
 
 inline Tensor sort_strides(Tensor& tensor_) {
-  IntList strides = tensor_.strides();
+  IntArrayRef strides = tensor_.strides();
   std::vector<int64_t> indices;
   indices.reserve(tensor_.ndimension());
   for (int64_t i = 0; i < tensor_.ndimension(); i++) {

aten/src/ATen/DLConvertor.cpp

@@ -172,8 +172,8 @@ Tensor fromDLPack(const DLManagedTensor* src) {
     src->deleter(const_cast<DLManagedTensor*>(src));
   };
   return at::from_blob(src->dl_tensor.data,
-      IntList(src->dl_tensor.shape, src->dl_tensor.ndim),
-      IntList(src->dl_tensor.strides, src->dl_tensor.ndim),
+      IntArrayRef(src->dl_tensor.shape, src->dl_tensor.ndim),
+      IntArrayRef(src->dl_tensor.strides, src->dl_tensor.ndim),
       deleter,
       at::device(device_type).dtype(stype));
 }

aten/src/ATen/Declarations.cwrap

@@ -29,8 +29,8 @@
         - THTensor* self
         - THStorage* source
         - long storage_offset
-        - IntListSize size
-        - arg: IntList stride
+        - IntArrayRefSize size
+        - arg: IntArrayRef stride
           default: {}
 ]]
 [[
@@ -131,7 +131,7 @@
   return: THTensor*
   arguments:
     - THTensor* self
-    - arg: IntListSize size
+    - arg: IntArrayRefSize size
       long_args: True
 ]]
 [[

aten/src/ATen/ExpandUtils.cpp

@@ -2,7 +2,7 @@
 
 namespace at {
 
-std::vector<int64_t> infer_size(IntList a, IntList b) {
+std::vector<int64_t> infer_size(IntArrayRef a, IntArrayRef b) {
   auto dimsA = a.size();
   auto dimsB = b.size();
   ptrdiff_t ndim = dimsA > dimsB ? dimsA : dimsB;
@@ -29,9 +29,9 @@ std::vector<int64_t> infer_size(IntList a, IntList b) {
 }
 
 std::tuple<std::vector<int64_t>, std::vector<int64_t>> inferExpandGeometry(
-    IntList tensor_sizes,
-    IntList tensor_strides,
-    IntList sizes) {
+    IntArrayRef tensor_sizes,
+    IntArrayRef tensor_strides,
+    IntArrayRef sizes) {
   int64_t ndim = sizes.size();
   int64_t tensor_dim = tensor_sizes.size();
 

aten/src/ATen/ExpandUtils.h

@@ -9,12 +9,12 @@
 
 namespace at {
 
-CAFFE2_API std::vector<int64_t> infer_size(IntList a, IntList b);
+CAFFE2_API std::vector<int64_t> infer_size(IntArrayRef a, IntArrayRef b);
 CAFFE2_API std::tuple<std::vector<int64_t>, std::vector<int64_t>>
 inferExpandGeometry(
-    IntList tensor_sizes,
-    IntList tensor_strides,
-    IntList sizes);
+    IntArrayRef tensor_sizes,
+    IntArrayRef tensor_strides,
+    IntArrayRef sizes);
 
 // avoid copy-construction of Tensor by using a reference_wrapper.
 inline void check_defined(std::initializer_list<std::reference_wrapper<const Tensor>> tensors, const char *api_name) {
@@ -93,15 +93,15 @@ inline std::tuple<Tensor, Tensor, Tensor> expand_outplace(const Tensor &to_expan
   return expand_outplace(to_expand1, to_expand2, to_expand3);
 }
 
-inline std::tuple<Tensor> expand_size(const Tensor &to_expand, IntList sizes) {
+inline std::tuple<Tensor> expand_size(const Tensor &to_expand, IntArrayRef sizes) {
   if(to_expand.sizes().equals(sizes)) {
     return std::make_tuple(to_expand);
   }
 
   return std::make_tuple(to_expand.expand(sizes, /*implicit=*/true)); // see [expand implicit]
 }
 
-inline std::tuple<Tensor> expand_size(const Tensor &to_expand, IntList sizes, const char *api_name) {
+inline std::tuple<Tensor> expand_size(const Tensor &to_expand, IntArrayRef sizes, const char *api_name) {
   check_defined({to_expand}, api_name);
   return expand_size(to_expand, sizes);
 }
@@ -136,12 +136,12 @@ inline std::vector<Tensor> expand_outplace(TensorList to_expand) {
 
 // Sums `tensor` repeatedly to produce a tensor of shape `shape`.
 // Precondition: is_expandable_to(shape, tensor.sizes()) must be true
-static inline Tensor sum_to(Tensor tensor, const IntList shape) {
+static inline Tensor sum_to(Tensor tensor, const IntArrayRef shape) {
   if (shape.size() == 0) {
     return tensor.sum();
   }
   c10::SmallVector<int64_t, 8> reduce_dims;
-  const at::IntList sizes = tensor.sizes();
+  const at::IntArrayRef sizes = tensor.sizes();
   const int64_t leading_dims = sizes.size() - shape.size();
   for (int64_t i = 0; i < leading_dims; ++i) {
     reduce_dims.push_back(i);
@@ -158,7 +158,7 @@ static inline Tensor sum_to(Tensor tensor, const IntList shape) {
 }
 
 // True if `shape` can be broadcasted to `desired`
-static inline bool is_expandable_to(IntList shape, IntList desired) {
+static inline bool is_expandable_to(IntArrayRef shape, IntArrayRef desired) {
   int ndim = shape.size();
   int target_dim = desired.size();
   if (ndim > target_dim) {

aten/src/ATen/InferSize.h

@@ -9,7 +9,7 @@ namespace at {
 
 // Infers the size of a dim with size -1, if it exists. Also checks that new
 // shape is compatible with the number of elements.
-static std::vector<int64_t> infer_size(IntList shape, int64_t numel) {
+static std::vector<int64_t> infer_size(IntArrayRef shape, int64_t numel) {
   auto res = shape.vec();
   int64_t newsize = 1;
   auto infer_dim = c10::optional<int64_t>();

aten/src/ATen/SparseTensorImpl.cpp

@@ -37,10 +37,10 @@ SparseTensorImpl::SparseTensorImpl(at::TensorTypeId type_id, const caffe2::TypeM
     , indices_(at::empty({1, 0}, at::initialTensorOptions().device(sparseTensorIdToDeviceType(type_id)).dtype(ScalarType::Long)))
     , values_(at::empty({0}, at::initialTensorOptions().device(sparseTensorIdToDeviceType(type_id)).dtype(data_type))) {}
 
-IntList SparseTensorImpl::sizes() const {
+IntArrayRef SparseTensorImpl::sizes() const {
   return sizes_;
 }
-IntList SparseTensorImpl::strides() const {
+IntArrayRef SparseTensorImpl::strides() const {
   AT_ERROR("sparse tensors do not have strides");
 }
 bool SparseTensorImpl::is_contiguous() const {
@@ -98,7 +98,7 @@ void SparseTensorImpl::set_indices_and_values_unsafe(const Tensor& indices, cons
   auto dense_size_original = sizes().slice(sparse_dim_);
   std::vector<int64_t> expected_values_size_vec = {values.size(0)};
   expected_values_size_vec.insert(expected_values_size_vec.end(), dense_size_original.begin(), dense_size_original.end());
-  IntList expected_values_size(expected_values_size_vec);
+  IntArrayRef expected_values_size(expected_values_size_vec);
   auto new_values_size = values.sizes();
   AT_CHECK(
     std::equal(expected_values_size.begin(), expected_values_size.end(), new_values_size.begin()),

aten/src/ATen/SparseTensorImpl.h

@@ -40,8 +40,8 @@ struct CAFFE2_API SparseTensorImpl : public TensorImpl {
   Tensor indices() const { return indices_; }
   Tensor values() const { return values_; }
 
-  IntList sizes() const override;
-  IntList strides() const override;
+  IntArrayRef sizes() const override;
+  IntArrayRef strides() const override;
   bool is_contiguous() const override;
   int64_t stride(int64_t d) const override;
   void resize_dim(int64_t ndim) override;
@@ -56,7 +56,7 @@ struct CAFFE2_API SparseTensorImpl : public TensorImpl {
 
   // WARNING: This function does NOT preserve invariants of sparse_dim/dense_dim with
   // respect to indices and values
-  void raw_resize_(int64_t sparse_dim, int64_t dense_dim, IntList size) {
+  void raw_resize_(int64_t sparse_dim, int64_t dense_dim, IntArrayRef size) {
     AT_CHECK(allow_tensor_metadata_change(), "raw_resize_ is not allowed on Tensor created from .data or .detach()");
     sizes_ = size.vec();
     sparse_dim_ = sparse_dim;
@@ -86,7 +86,7 @@ struct CAFFE2_API SparseTensorImpl : public TensorImpl {
   // and for API consistency we don't support it).
   // 4. When we attempt to shrink the size of any of the sparse dimensions on a non-empty sparse tensor
   // (this could make some of the stored indices out-of-bound and thus unsafe).
-  void resize_(int64_t sparse_dim, int64_t dense_dim, IntList size) {
+  void resize_(int64_t sparse_dim, int64_t dense_dim, IntArrayRef size) {
     AT_CHECK(allow_tensor_metadata_change(), "resize_ is not allowed on Tensor created from .data or .detach()");
     AT_CHECK(sparse_dim + dense_dim == static_cast<int64_t>(size.size()), "number of dimensions must be sparse_dim (", sparse_dim, ") + dense_dim (", dense_dim, "), but got ", size.size());
     if (nnz() > 0) {
@@ -144,7 +144,7 @@ struct CAFFE2_API SparseTensorImpl : public TensorImpl {
   }
 
   // NOTE: this function will resize the sparse tensor and also set `indices` and `values` to empty.
-  void resize_and_clear_(int64_t sparse_dim, int64_t dense_dim, IntList size) {
+  void resize_and_clear_(int64_t sparse_dim, int64_t dense_dim, IntArrayRef size) {
     AT_CHECK(allow_tensor_metadata_change(), "resize_and_clear_ is not allowed on Tensor created from .data or .detach()");
     AT_CHECK(sparse_dim + dense_dim == static_cast<int64_t>(size.size()), "number of dimensions must be sparse_dim (", sparse_dim, ") + dense_dim (", dense_dim, "), but got ", size.size());
 

aten/src/ATen/SparseTensorUtils.h

@@ -66,7 +66,7 @@ inline Tensor new_values_with_size_of(const Tensor& values, int64_t nnz) {
 // the flattened tensor `t.reshape( prod(full_size[:indices.size(0)]), -1 )`.
 // if forceClone is true, the result will forced to be a clone of self.
 // if force_clone is true, the result will forced to be a clone of self.
-inline LongTensor flatten_indices(const Tensor& indices, IntList full_size, bool force_clone = false) {
+inline LongTensor flatten_indices(const Tensor& indices, IntArrayRef full_size, bool force_clone = false) {
   int64_t sparse_dim = indices.size(0);
   if (sparse_dim == 1) {
     if (force_clone) {
@@ -113,7 +113,7 @@ inline LongTensor flatten_indices(const Tensor& indices, IntList full_size, bool
 // Ex2:
 //   dims_to_flatten = [1]
 //   new_indices = [ 3, 1, 3 ]  # uncoalesced
-inline LongTensor flatten_indices_by_dims(const LongTensor& indices, const IntList& sizes, const IntList& dims_to_flatten){
+inline LongTensor flatten_indices_by_dims(const LongTensor& indices, const IntArrayRef& sizes, const IntArrayRef& dims_to_flatten){
   LongTensor new_indices = at::zeros({indices.size(1)}, indices.options());
   for (auto d : dims_to_flatten) {
     new_indices.mul_(sizes[d]);

aten/src/ATen/TensorGeometry.h

@@ -8,7 +8,7 @@ namespace at {
 struct CAFFE2_API TensorGeometry {
   TensorGeometry() : storage_offset_(0) {}
 
-  explicit TensorGeometry(IntList sizes)
+  explicit TensorGeometry(IntArrayRef sizes)
     : sizes_(sizes.vec())
     , strides_(sizes.size())
     , storage_offset_(0) {
@@ -35,12 +35,12 @@ struct CAFFE2_API TensorGeometry {
     dim = maybe_wrap_dim(dim, this->dim());
     return sizes_.at(static_cast<size_t>(dim));
   }
-  IntList sizes() const { return IntList{ sizes_ }; }
+  IntArrayRef sizes() const { return IntArrayRef{ sizes_ }; }
   int64_t stride(int64_t dim) const {
     dim = maybe_wrap_dim(dim, this->dim());
     return strides_.at(static_cast<size_t>(dim));
   }
-  IntList strides() const { return IntList{ strides_ }; }
+  IntArrayRef strides() const { return IntArrayRef{ strides_ }; }
   int64_t storage_offset() const { return storage_offset_; }
   int64_t numel() const { return numel_; }
 

aten/src/ATen/TensorUtils.cpp

@@ -47,7 +47,7 @@ void checkAllContiguous(CheckedFrom c, at::ArrayRef<TensorArg> ts) {
   }
 }
 
-void checkSize(CheckedFrom c, const TensorGeometryArg& t, IntList sizes) {
+void checkSize(CheckedFrom c, const TensorGeometryArg& t, IntArrayRef sizes) {
   checkDim(c, t, sizes.size());
   AT_CHECK(
     t->sizes().equals(sizes),
@@ -217,7 +217,7 @@ void * maybe_data_ptr(const TensorArg& tensor) {
 }
 
 // See TensorUtils.h on why this is useful now that we cache is_contiguous.
-bool geometry_is_contiguous(IntList sizes, IntList strides) {
+bool geometry_is_contiguous(IntArrayRef sizes, IntArrayRef strides) {
   int64_t dim = sizes.size();
   int64_t expected_stride = 1;
   bool contig_if_nonempty = true;

aten/src/ATen/TensorUtils.h

@@ -69,7 +69,7 @@ CAFFE2_API void checkAllContiguous(CheckedFrom c, at::ArrayRef<TensorArg> ts);
 CAFFE2_API void checkSize(
     CheckedFrom c,
     const TensorGeometryArg& t,
-    IntList sizes);
+    IntArrayRef sizes);
 CAFFE2_API void checkSize(
     CheckedFrom c,
     const TensorGeometryArg& t,
@@ -124,5 +124,5 @@ CAFFE2_API void* maybe_data_ptr(const TensorArg& tensor);
 // allows checking if a particular geometry is contiguous without explicitly
 // constructing a tensor, e.g., when you want to choose a kernel strategy based
 // on whether a subgeometry is contiguous.
-CAFFE2_API bool geometry_is_contiguous(IntList sizes, IntList strides);
+CAFFE2_API bool geometry_is_contiguous(IntArrayRef sizes, IntArrayRef strides);
 }

aten/src/ATen/WrapDimUtilsMulti.h

@@ -12,7 +12,7 @@ namespace at {
 
 constexpr size_t dim_bitset_size = 64;
 
-static inline std::bitset<dim_bitset_size> dim_list_to_bitset(IntList dims, int64_t ndims) {
+static inline std::bitset<dim_bitset_size> dim_list_to_bitset(IntArrayRef dims, int64_t ndims) {
   AT_CHECK(ndims <= (int64_t) dim_bitset_size, "only tensors with up to ", dim_bitset_size, " dims are supported");
   std::bitset<dim_bitset_size> seen;
   for (size_t i = 0; i < dims.size(); i++) {