Improve swift::TransformRange enough to delete TransformArrayRef

We have a lot of "transform a range" types already:
llvm::mapped_iterator, swift::TransformRange and
swift::TransformIterator, and swift::ArrayRefView for static
transformations. This gets rid of one more layer without losing
any real functionality.

Author: jrose-apple

include/swift/Basic/STLExtras.h

@@ -488,7 +488,7 @@ class TransformRange {
   Operation Op;
 
 public:
-  using iterator = TransformIterator<typename Range::iterator, Operation>;
+  using iterator = TransformIterator<decltype(Rng.begin()), Operation>;
 
   TransformRange(Range range, Operation op)
     : Rng(range), Op(op) { }
@@ -497,6 +497,20 @@ class TransformRange {
   iterator end() const { return iterator(Rng.end(), Op); }
   bool empty() const { return begin() == end(); }
 
+  // The dummy template parameter keeps 'size()' from being eagerly
+  // instantiated.
+  template <typename Dummy = Range>
+  typename function_traits<decltype(&Dummy::size)>::result_type
+  size() const {
+    return Rng.size();
+  }
+
+  template <typename Index>
+  typename function_traits<Operation>::result_type
+  operator[](Index index) const {
+    return Op(Rng[index]);
+  }
+
   typename std::iterator_traits<iterator>::value_type front() const { 
     assert(!empty() && "Front of empty range");
     return *begin(); 

include/swift/Basic/TransformArrayRef.h

@@ -22,7 +22,6 @@
 
 #include "swift/Basic/LLVM.h"
 #include "swift/Basic/STLExtras.h"
-#include "swift/Basic/TransformArrayRef.h"
 
 namespace swift {
 
@@ -31,10 +30,11 @@ class SILPhiArgument;
 class SILFunctionArgument;
 
 using PhiArgumentArrayRef =
-    TransformArrayRef<function_ref<SILPhiArgument *(SILArgument *)>>;
+    TransformRange<ArrayRef<SILArgument *>, SILPhiArgument *(*)(SILArgument *)>;
 
 using FunctionArgumentArrayRef =
-    TransformArrayRef<function_ref<SILFunctionArgument *(SILArgument *)>>;
+    TransformRange<ArrayRef<SILArgument *>,
+                   SILFunctionArgument *(*)(SILArgument *)>;
 
 } // namespace swift
 

include/swift/SIL/SILArgumentArrayRef.h

@@ -19,7 +19,6 @@
 
 #include "swift/Basic/Compiler.h"
 #include "swift/Basic/Range.h"
-#include "swift/Basic/TransformArrayRef.h"
 #include "swift/SIL/SILArgumentArrayRef.h"
 #include "swift/SIL/SILInstruction.h"
 

include/swift/SIL/SILBasicBlock.h

@@ -20,7 +20,6 @@
 #include "swift/AST/Types.h"
 #include "swift/Basic/Range.h"
 #include "swift/Basic/STLExtras.h"
-#include "swift/Basic/TransformArrayRef.h"
 #include "swift/ClangImporter/ClangModule.h"
 #include "swift/SIL/BasicBlockUtils.h"
 #include "swift/SIL/BranchPropagatedUser.h"

lib/SIL/SILOwnershipVerifier.cpp

@@ -27,7 +27,7 @@ add_swift_unittest(SwiftBasicTests
   StringExtrasTest.cpp
   SuccessorMapTest.cpp
   ThreadSafeRefCntPointerTest.cpp
-  TransformArrayRefTest.cpp
+  TransformRangeTest.cpp
   TreeScopedHashTableTest.cpp
   UnicodeTest.cpp
   ValueEnumeratorTest.cpp

unittests/Basic/CMakeLists.txt

@@ -1,29 +1,30 @@
-//===--- TransformArrayRefTest.cpp ----------------------------------------===//
+//===--- TransformRangeTest.cpp -------------------------------------------===//
 //
 // This source file is part of the Swift.org open source project
 //
-// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Copyright (c) 2014 - 2019 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/Basic/TransformArrayRef.h"
+#include "swift/Basic/STLExtras.h"
+#include "llvm/ADT/ArrayRef.h"
 #include "gtest/gtest.h"
 
 using namespace swift;
 
-TEST(TransformArrayRefTest, Empty) {
+TEST(TransformRangeTest, Empty) {
   auto transform = [](int i) -> float { return float(i); };
   std::function<float (int)> f(transform);
   std::vector<int> v1;
-  auto EmptyArray = makeTransformArrayRef(llvm::ArrayRef<int>(v1), f);
+  auto EmptyArray = makeTransformRange(llvm::ArrayRef<int>(v1), f);
   EXPECT_EQ(EmptyArray.empty(), v1.empty());
 }
 
-TEST(TransformArrayRefTest, Subscript) {
+TEST(TransformRangeTest, Subscript) {
   auto transform = [](int i) -> float { return float(i); };
   std::function<float (int)> f(transform);
   std::vector<int> v1;
@@ -35,15 +36,15 @@ TEST(TransformArrayRefTest, Subscript) {
   v1.push_back(-5);
   v1.push_back(-30);
 
-  auto Array = makeTransformArrayRef(llvm::ArrayRef<int>(v1), f);
+  auto Array = makeTransformRange(llvm::ArrayRef<int>(v1), f);
 
   EXPECT_EQ(Array.size(), v1.size());
   for (unsigned i = 0, e = Array.size(); i != e; ++i) {
     EXPECT_EQ(Array[i], transform(v1[i]));
   }
 }
 
-TEST(TransformArrayRefTest, Iteration) {
+TEST(TransformRangeTest, Iteration) {
   auto transform = [](int i) -> float { return float(i); };
   std::function<float (int)> f(transform);
   std::vector<int> v1;
@@ -55,7 +56,7 @@ TEST(TransformArrayRefTest, Iteration) {
   v1.push_back(-5);
   v1.push_back(-30);
 
-  auto Array = makeTransformArrayRef(llvm::ArrayRef<int>(v1), f);
+  auto Array = makeTransformRange(llvm::ArrayRef<int>(v1), f);
 
   auto VBegin = v1.begin();
   auto VIter = v1.begin();
@@ -83,7 +84,7 @@ TEST(TransformArrayRefTest, Iteration) {
   }
 }
 
-TEST(TransformArrayRefTest, Slicing) {
+TEST(TransformRangeTest, IterationWithSizelessSubscriptlessRange) {
   auto transform = [](int i) -> float { return float(i); };
   std::function<float (int)> f(transform);
   std::vector<int> v1;
@@ -95,13 +96,30 @@ TEST(TransformArrayRefTest, Slicing) {
   v1.push_back(-5);
   v1.push_back(-30);
 
-  auto Array = llvm::ArrayRef<int>(v1);
-  auto TArray = makeTransformArrayRef(Array, f);
+  auto Array = makeTransformRange(llvm::make_range(v1.begin(), v1.end()), f);
 
-  EXPECT_EQ(Array.size(), TArray.size());
-  while (!Array.empty()) {
-    EXPECT_EQ(transform(*Array.begin()), *TArray.begin());
-    Array = Array.slice(1);
-    TArray = TArray.slice(1);
+  auto VBegin = v1.begin();
+  auto VIter = v1.begin();
+  auto VEnd = v1.end();
+  auto TBegin = Array.begin();
+  auto TIter = Array.begin();
+  auto TEnd = Array.end();
+
+  // Forwards.
+  while (VIter != VEnd) {
+    EXPECT_NE(TIter, TEnd);
+    EXPECT_EQ(transform(*VIter), *TIter);
+    ++VIter;
+    ++TIter;
+  }
+
+  // Backwards.
+  while (VIter != VBegin) {
+    EXPECT_NE(TIter, TBegin);
+
+    --VIter;
+    --TIter;
+
+    EXPECT_EQ(transform(*VIter), *TIter);
   }
 }