[llvm] Let SmallVector construct from any Iterable

[gchatelet]

Summary

SmallVector can be constructed from llvm::iterable_range but not from other ranges.
This patch allows to construct SmallVector from any Iterable type.

[gchatelet]

• Remove dependency on iterable_range header

[gchatelet]

• Remove dependency on iterable_range header
• Simplified implementation, added tests

[gchatelet]

• Forward argument

[fhahn]

clang/include/clang/Basic/Module.h

98

how is this related?

llvm/tools/llvm-xray/xray-converter.cpp

161

how is this related?

[gchatelet]

clang/include/clang/Basic/Module.h

98

how is this related?

I'm glad you ask! I'm still investigating the errors that led to this addition (and the one in llvm/tools/llvm-xray/xray-converter.cpp) but I suspect this is due to the recursive nature of these classes.
Both Module and StackIdData contains self-referencing SmallVector. It is unclear to me why the compiler is trying to instantiate the newly added SmallVector constructor during type declaration.

I'll post the compiler errors below the additions.

98

FAILED: tools/clang/lib/Lex/CMakeFiles/obj.clangLex.dir/HeaderSearch.cpp.o 
/redacted/build-llvm/download/clang/bin/clang++ --sysroot=/redacted/build-llvm/download/sysroot -DGTEST_HAS_RTTI=0 -D_GNU_SOURCE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -Itools/clang/lib/Lex -I/redacted/git/llvm-project/clang/lib/Lex -I/redacted/git/llvm-project/clang/include -Itools/clang/include -Iinclude -I/redacted/git/llvm-project/llvm/include -fPIC -fvisibility-inlines-hidden -Werror=date-time -Werror=unguarded-availability-new -Wall -Wextra -Wno-unused-parameter -Wwrite-strings -Wcast-qual -Wmissing-field-initializers -pedantic -Wno-long-long -Wc++98-compat-extra-semi -Wimplicit-fallthrough -Wcovered-switch-default -Wno-noexcept-type -Wnon-virtual-dtor -Wdelete-non-virtual-dtor -Wsuggest-override -Wstring-conversion -Wmisleading-indentation -fdiagnostics-color -ffunction-sections -fdata-sections -fno-common -Woverloaded-virtual -Wno-nested-anon-types -O3 -DNDEBUG  -fno-exceptions -fno-rtti -std=c++14 -MD -MT tools/clang/lib/Lex/CMakeFiles/obj.clangLex.dir/HeaderSearch.cpp.o -MF tools/clang/lib/Lex/CMakeFiles/obj.clangLex.dir/HeaderSearch.cpp.o.d -o tools/clang/lib/Lex/CMakeFiles/obj.clangLex.dir/HeaderSearch.cpp.o -c /redacted/git/llvm-project/clang/lib/Lex/HeaderSearch.cpp
In file included from /redacted/git/llvm-project/clang/lib/Lex/HeaderSearch.cpp:13:
In file included from /redacted/git/llvm-project/clang/include/clang/Lex/HeaderSearch.h:16:
In file included from /redacted/git/llvm-project/clang/include/clang/Basic/SourceLocation.h:19:
/redacted/git/llvm-project/llvm/include/llvm/Support/PointerLikeTypeTraits.h:61:28: error: invalid application of 'alignof' to an incomplete type 'clang::Module'
      detail::ConstantLog2<alignof(T)>::value;
                           ^~~~~~~~~~
/redacted/git/llvm-project/llvm/include/llvm/ADT/IterableTraits.h:23:33: note: in instantiation of template class 'llvm::PointerLikeTypeTraits<clang::Module *>' requested here
    std::next(std::declval<I>()),
                                ^
/redacted/git/llvm-project/llvm/include/llvm/ADT/IterableTraits.h:36:39: note: while substituting explicitly-specified template arguments into function template 'is_forward_iterator' 
struct is_forward_iterator : decltype(detail::is_forward_iterator<I>(0)) {};
                                      ^
/redacted/git/llvm-project/llvm/include/llvm/ADT/IterableTraits.h:46:42: note: in instantiation of template class 'llvm::is_forward_iterator<const llvm::PointerIntPair<clang::Module *, 1, bool> *>' requested here
                                         llvm::is_forward_iterator<I>{});
                                         ^
/redacted/git/llvm-project/llvm/include/llvm/ADT/IterableTraits.h:51:37: note: while substituting deduced template arguments into function template 'is_range_iterable' [with T = const llvm::SmallVector<llvm::PointerIntPair<clang::Module *, 1, bool>, 2> &, I = (no value)]
struct is_range_iterable : decltype(detail::is_range_iterable<T>(0)) {};
                                    ^
/redacted/git/llvm-project/llvm/include/llvm/ADT/SmallVector.h:1194:30: note: in instantiation of template class 'llvm::is_range_iterable<const llvm::SmallVector<llvm::PointerIntPair<clang::Module *, 1, bool>, 2> &>' requested here
      std::enable_if_t<llvm::is_range_iterable<Iterable>::value, bool> = true)
                             ^
/redacted/git/llvm-project/llvm/include/llvm/ADT/SmallVector.h:1168:22: note: while substituting deduced template arguments into function template 'SmallVector' [with Iterable = const llvm::SmallVector<llvm::PointerIntPair<clang::Module *, 1, bool>, 2> &]
class LLVM_GSL_OWNER SmallVector : public SmallVectorImpl<T>,
                     ^
/redacted/git/llvm-project/clang/include/clang/Basic/Module.h:96:7: note: while declaring the implicit copy constructor for 'Module'
class Module {
      ^
/redacted/git/llvm-project/clang/include/clang/Basic/Module.h:96:7: note: definition of 'clang::Module' is not complete until the closing '}'
1 error generated.

llvm/tools/llvm-xray/xray-converter.cpp

161

FAILED: tools/llvm-xray/CMakeFiles/llvm-xray.dir/xray-converter.cpp.o 
/redacted/build-llvm/download/clang/bin/clang++ --sysroot=/redacted/build-llvm/download/sysroot -DGTEST_HAS_RTTI=0 -D_GNU_SOURCE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -Itools/llvm-xray -I/redacted/git/llvm-project/llvm/tools/llvm-xray -Iinclude -I/redacted/git/llvm-project/llvm/include -fPIC -fvisibility-inlines-hidden -Werror=date-time -Werror=unguarded-availability-new -Wall -Wextra -Wno-unused-parameter -Wwrite-strings -Wcast-qual -Wmissing-field-initializers -pedantic -Wno-long-long -Wc++98-compat-extra-semi -Wimplicit-fallthrough -Wcovered-switch-default -Wno-noexcept-type -Wnon-virtual-dtor -Wdelete-non-virtual-dtor -Wsuggest-override -Wstring-conversion -Wmisleading-indentation -fdiagnostics-color -ffunction-sections -fdata-sections -O3 -DNDEBUG  -fno-exceptions -fno-rtti -std=c++14 -MD -MT tools/llvm-xray/CMakeFiles/llvm-xray.dir/xray-converter.cpp.o -MF tools/llvm-xray/CMakeFiles/llvm-xray.dir/xray-converter.cpp.o.d -o tools/llvm-xray/CMakeFiles/llvm-xray.dir/xray-converter.cpp.o -c /redacted/git/llvm-project/llvm/tools/llvm-xray/xray-converter.cpp
In file included from /redacted/git/llvm-project/llvm/tools/llvm-xray/xray-converter.cpp:14:
/redacted/git/llvm-project/llvm/tools/llvm-xray/trie-node.h:41:18: error: field has incomplete type '(anonymous namespace)::StackIdData'
  AssociatedData ExtraData;
                 ^
/redacted/git/llvm-project/llvm/include/llvm/ADT/IterableTraits.h:23:33: note: in instantiation of template class 'TrieNode<(anonymous namespace)::StackIdData>' requested here
    std::next(std::declval<I>()),
                                ^
/redacted/git/llvm-project/llvm/include/llvm/ADT/IterableTraits.h:36:39: note: while substituting explicitly-specified template arguments into function template 'is_forward_iterator' 
struct is_forward_iterator : decltype(detail::is_forward_iterator<I>(0)) {};
                                      ^
/redacted/git/llvm-project/llvm/include/llvm/ADT/IterableTraits.h:46:42: note: in instantiation of template class 'llvm::is_forward_iterator<TrieNode<(anonymous namespace)::StackIdData> *const *>' requested here
                                         llvm::is_forward_iterator<I>{});
                                         ^
/redacted/git/llvm-project/llvm/include/llvm/ADT/IterableTraits.h:51:37: note: while substituting deduced template arguments into function template 'is_range_iterable' [with T = const llvm::SmallVector<TrieNode<(anonymous namespace)::StackIdData> *, 4> &, I = (no value)]
struct is_range_iterable : decltype(detail::is_range_iterable<T>(0)) {};
                                    ^
/redacted/git/llvm-project/llvm/include/llvm/ADT/SmallVector.h:1194:30: note: in instantiation of template class 'llvm::is_range_iterable<const llvm::SmallVector<TrieNode<(anonymous namespace)::StackIdData> *, 4> &>' requested here
      std::enable_if_t<llvm::is_range_iterable<Iterable>::value, bool> = true)
                             ^
/redacted/git/llvm-project/llvm/include/llvm/ADT/SmallVector.h:1168:22: note: while substituting deduced template arguments into function template 'SmallVector' [with Iterable = const llvm::SmallVector<TrieNode<(anonymous namespace)::StackIdData> *, 4> &]
class LLVM_GSL_OWNER SmallVector : public SmallVectorImpl<T>,
                     ^
/redacted/git/llvm-project/llvm/tools/llvm-xray/xray-converter.cpp:160:8: note: while declaring the implicit copy constructor for 'StackIdData'
struct StackIdData {
       ^
/redacted/git/llvm-project/llvm/tools/llvm-xray/xray-converter.cpp:160:8: note: definition of '(anonymous namespace)::StackIdData' is not complete until the closing '}'
/redacted/git/llvm-project/llvm/tools/llvm-xray/xray-converter.cpp:225:15: error: no matching member function for call to 'push_front'
    NodeStore.push_front({FuncId, Parent, {}, {(*id_counter)++, {}}});
    ~~~~~~~~~~^~~~~~~~~~
/redacted/build-llvm/download/sysroot/usr/lib/gcc/x86_64-linux-gnu/7/../../../../include/c++/7/bits/forward_list.h:822:7: note: candidate function not viable: cannot convert initializer list argument to 'const TrieNode<(anonymous namespace)::StackIdData>'
      push_front(const _Tp& __val)
      ^
/redacted/build-llvm/download/sysroot/usr/lib/gcc/x86_64-linux-gnu/7/../../../../include/c++/7/bits/forward_list.h:829:7: note: candidate function not viable: cannot convert initializer list argument to 'TrieNode<(anonymous namespace)::StackIdData>'
      push_front(_Tp&& __val)
      ^
/redacted/git/llvm-project/llvm/tools/llvm-xray/xray-converter.cpp:232:13: error: no matching member function for call to 'push_front'
  NodeStore.push_front({FuncId, Parent, {}, {stack_id, std::move(siblings)}});
  ~~~~~~~~~~^~~~~~~~~~
/redacted/build-llvm/download/sysroot/usr/lib/gcc/x86_64-linux-gnu/7/../../../../include/c++/7/bits/forward_list.h:822:7: note: candidate function not viable: cannot convert initializer list argument to 'const TrieNode<(anonymous namespace)::StackIdData>'
      push_front(const _Tp& __val)
      ^
/redacted/build-llvm/download/sysroot/usr/lib/gcc/x86_64-linux-gnu/7/../../../../include/c++/7/bits/forward_list.h:829:7: note: candidate function not viable: cannot convert initializer list argument to 'TrieNode<(anonymous namespace)::StackIdData>'
      push_front(_Tp&& __val)
      ^
3 errors generated.

[gchatelet]

• Rebase

[• Quuxplusone]

llvm/include/llvm/ADT/IterableTraits.h

17–31

Instead of all this, I would recommend

template<class It>
using is_input_iterator = std::is_base_of<std::input_iterator_tag, typename std::iterator_traits<It>::iterator_category>;

template<class R>
using iterator_type_of = std::decay_t<decltype(std::begin(std::declval<R>()))>;

template<class R, class IsInputIterable = std::true_type>
struct is_range_iterable : std::false_type {};

template<class R>
struct is_range_iterable<R, typename is_input_iterator<iterator_type_of<R>>::type> : std::true_type {};

(Notice that we're supposed to be checking for input iterability, not forward iterability. But also, the right way to see if something is an input iterator is not to check an ad-hoc bunch of operators like * and !=, but simply to check its STL iterator category.)

However, in real life, I personally would reject this patch, because I think "saving a couple of calls to begin/end at the call site" is not worth the peril of letting people accidentally write e.g.

SmallVector<SomeKindaString> v("hello world");
assert(v.size() == 12);  // elements are "h"s, "e"s, "l"s, etc.

llvm/include/llvm/ADT/SmallVector.h

1191–1194

Watch out: this greedy constructor template will be used for non-const copy construction, e.g.

SmallVector<int> x;
SmallVector<int> y = x;  // calls SmallVector<int>::SmallVector<SmallVector<int>&>(SmallVector<int>&, bool),
// which is a better match than SmallVector<int>::SmallVector(const SmallVector<int>&)

[courbet]

clang/include/clang/Basic/Module.h

98

For reference, the issue is that std::next takes its parameter by value: https://godbolt.org/z/531f3f86s.

(though I'm not sure we want to move forward with this patch given @Quuxplusone's comments)

[gchatelet]

@Quuxplusone thx a lot for the comment. It is very relevant and I agree that this addition may be dangerous.
The intend was to prevent adding more constructors (and dependencies) to SmallVector in D102679.
I can try to see what it takes to call begin and end explicitly.

[• Quuxplusone]

@gchatelet: Thanks for the link to D102679 — that seems like very relevant background info I didn't have! Having looked through D102679, though, I don't see how it would benefit from D102760 — in fact, D102679 updates some tests to wisely stop depending on the ability to construct SmallVector from a range (and goes to using begin/end pairs instead — good!).
So I think D102679 is a good idea (modulo the review comments I just left), and I continue to think that this D102760 is a bad idea that should be abandoned.

[gchatelet]

In D102760#2802520, @Quuxplusone wrote:

@gchatelet: Thanks for the link to D102679 — that seems like very relevant background info I didn't have! Having looked through D102679, though, I don't see how it would benefit from D102760 — in fact, D102679 updates some tests to wisely stop depending on the ability to construct SmallVector from a range (and goes to using begin/end pairs instead — good!).

Yes these (recent) changes are based on your comments : )

So I think D102679 is a good idea (modulo the review comments I just left), and I continue to think that this D102760 is a bad idea that should be abandoned.

This is my plan indeed. Thx for your insights. I really appreciate it.
I wanted to see the impact of removing the constructor first, it's very minor so I'll go ahead and abandon this change.

clang/include/clang/Basic/Module.h

static ASTFileSignature create(InputIt First, InputIt Last) {
     std::copy(First, Last, Signature.begin());
     return Signature;
   }
 };
 
 /// Describes a module or submodule.
 class Module {
 public:
+  Module(const Module &) = default;
+
   /// The name of this module.
   std::string Name;
 
   /// The location of the module definition.
   SourceLocation DefinitionLoc;
 
   enum ModuleKind {
     /// This is a module that was defined by a module map and built out

llvm/include/llvm/ADT/IterableTraits.h

+//===- IterableTraits.h - A trait to identify iterables ---------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_ADT_ITERABLETRAITS_H
+#define LLVM_ADT_ITERABLETRAITS_H
+
+#include <iterator>
+#include <type_traits>
+
+namespace llvm {
+
+namespace detail {
+
+template <typename I> auto is_forward_iterator(...) -> std::false_type;
+
+template <typename I>
+auto is_forward_iterator(int) -> decltype(
+    std::next(std::declval<I>()),
+    std::integral_constant<
+        bool,
+        std::is_convertible<decltype(std::declval<I>() != std::declval<I>()),
+                            bool>::value &&
+            !std::is_void<decltype(*std::declval<I>())>::value &&
+            std::is_copy_constructible<I>::value && true>{});
+
+} // namespace detail
+
+// A convenient trait to check whether a type provides the forward iterator
+// semantic.
+template <typename I>
+struct is_forward_iterator : decltype(detail::is_forward_iterator<I>(0)) {};
+
+namespace detail {
+
+template <typename T> auto is_range_iterable(...) -> std::false_type;
+
+template <typename T, typename I = typename std::decay_t<
+                          decltype(std::begin(std::declval<T>()))>>
+auto is_range_iterable(char) -> decltype(std::begin(std::declval<T>()), //
+                                         std::end(std::declval<T>()),   //
+                                         llvm::is_forward_iterator<I>{});
+} // namespace detail
+
+// A convenient trait to check whether a type provides the begin / end semantic.
+template <typename T>
+struct is_range_iterable : decltype(detail::is_range_iterable<T>(0)) {};
+
+} // namespace llvm
+
+#endif // LLVM_ADT_ITERABLETRAITS_H

llvm/include/llvm/ADT/SmallVector.h

 //===- llvm/ADT/SmallVector.h - 'Normally small' vectors --------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines the SmallVector class.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ADT_SMALLVECTOR_H
 #define LLVM_ADT_SMALLVECTOR_H
 
-#include "llvm/ADT/iterator_range.h"
+#include "llvm/ADT/IterableTraits.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/MemAlloc.h"
 #include "llvm/Support/type_traits.h"
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
public:
   template <typename ItTy,
             typename = std::enable_if_t<std::is_convertible<
                 typename std::iterator_traits<ItTy>::iterator_category,
                 std::input_iterator_tag>::value>>
   SmallVector(ItTy S, ItTy E) : SmallVectorImpl<T>(N) {
     this->append(S, E);
   }
 
-  template <typename RangeTy>
-  explicit SmallVector(const iterator_range<RangeTy> &R)
+  template <typename Iterable>
+  explicit SmallVector(
+      Iterable &&Range,
+      std::enable_if_t<llvm::is_range_iterable<Iterable>::value, bool> = true)
       : SmallVectorImpl<T>(N) {
-    this->append(R.begin(), R.end());
+    this->append(std::begin(std::forward<Iterable>(Range)),
+                 std::end(std::forward<Iterable>(Range)));
   }
 
   SmallVector(std::initializer_list<T> IL) : SmallVectorImpl<T>(N) {
     this->assign(IL);
   }
 
   SmallVector(const SmallVector &RHS) : SmallVectorImpl<T>(N) {
     if (!RHS.empty())

llvm/tools/llvm-xray/xray-converter.cpp

void TraceConverter::exportAsRAWv1(const Trace &Records, raw_ostream &OS) {
   }
 }
 
 namespace {
 
 // A structure that allows building a dictionary of stack ids for the Chrome
 // trace event format.
 struct StackIdData {
+  StackIdData(const StackIdData &) = default;
+
   // Each Stack of function calls has a unique ID.
   unsigned id;
 
   // Bookkeeping so that IDs can be maintained uniquely across threads.
   // Traversal keeps sibling pointers to other threads stacks. This is helpful
   // to determine when a thread encounters a new stack and should assign a new
   // unique ID.
   SmallVector<TrieNode<StackIdData> *, 4> siblings;

llvm/unittests/ADT/CMakeLists.txt

add_llvm_unittest(ADTTests
   IListSentinelTest.cpp
   IListTest.cpp
   ImmutableListTest.cpp
   ImmutableMapTest.cpp
   ImmutableSetTest.cpp
   IntEqClassesTest.cpp
   IntervalMapTest.cpp
   IntrusiveRefCntPtrTest.cpp
+  IterableTraitsTest.cpp
   IteratorTest.cpp
   MappedIteratorTest.cpp
   MapVectorTest.cpp
   OptionalTest.cpp
   PackedVectorTest.cpp
   PointerEmbeddedIntTest.cpp
   PointerIntPairTest.cpp
   PointerSumTypeTest.cpp

llvm/unittests/ADT/IterableTraitsTest.cpp

+//===- IterableTraitsTest.cpp - Unit tests for is_range_iterable ----------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/ADT/IterableTraits.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/iterator_range.h"
+#include "gtest/gtest.h"
+#include <array>
+#include <forward_list>
+#include <vector>
+
+namespace llvm {
+
+class ForwardDeclared;
+
+TEST(IteratorRangeTest, IsForwardIterator) {
+  EXPECT_FALSE(is_forward_iterator<int>::value);
+  EXPECT_TRUE(is_forward_iterator<int *>::value);
+  EXPECT_TRUE(is_forward_iterator<ForwardDeclared *>::value);
+  EXPECT_TRUE(is_forward_iterator<const ForwardDeclared *>::value);
+  using ForwardList = std::forward_list<int>;
+  EXPECT_TRUE(is_forward_iterator<ForwardList::iterator>::value);
+  EXPECT_TRUE(is_forward_iterator<ForwardList::const_iterator>::value);
+}
+
+TEST(IteratorRangeTest, IsIterableCArray) {
+  int Data[4];
+  EXPECT_TRUE(
+      is_range_iterable<std::add_lvalue_reference_t<decltype(Data)>>::value);
+}
+
+TEST(IteratorRangeTest, IsIterableVector) {
+  using Vector = std::vector<int>;
+  EXPECT_TRUE(is_range_iterable<Vector>::value);
+}
+
+TEST(IteratorRangeTest, IsIterableArray) {
+  using Array = std::array<int, 3>;
+  EXPECT_TRUE(is_range_iterable<Array>::value);
+}
+
+TEST(IteratorRangeTest, IsIterableSmallVector) {
+  using SVector = SmallVector<int, 3>;
+  EXPECT_TRUE(is_range_iterable<SVector>::value);
+}
+
+TEST(IteratorRangeTest, IsIterableRange) {
+  using Range = iterator_range<const ForwardDeclared *>;
+  EXPECT_TRUE(is_range_iterable<Range>::value);
+}
+
+TEST(IteratorRangeTest, NonIterableTypes) {
+  EXPECT_FALSE(is_range_iterable<int>::value);
+  EXPECT_FALSE(is_range_iterable<ForwardDeclared>::value);
+}
+
+} // namespace llvm

llvm/unittests/ADT/SmallVectorTest.cpp

 TYPED_TEST(SmallVectorTest, ConstructorIterTest) {
   SCOPED_TRACE("ConstructorTest");
   int arr[] = {1, 2, 3};
   this->theVector =
       SmallVector<Constructable, 4>(std::begin(arr), std::end(arr));
   this->assertValuesInOrder(this->theVector, 3u, 1, 2, 3);
 }
 
+// Constructor test.
+TYPED_TEST(SmallVectorTest, ConstructorIterableCArrayTest) {
+  SCOPED_TRACE("ConstructorTest");
+  int arr[] = {1, 2, 3};
+  this->theVector = SmallVector<Constructable, 4>(arr);
+  this->assertValuesInOrder(this->theVector, 3u, 1, 2, 3);
+}
+
+// Constructor test.
+TYPED_TEST(SmallVectorTest, ConstructorIterableVectorTest) {
+  SCOPED_TRACE("ConstructorTest");
+  std::vector<int> vec = {1, 2, 3};
+  this->theVector = SmallVector<Constructable, 4>(vec);
+  this->assertValuesInOrder(this->theVector, 3u, 1, 2, 3);
+}
+
 // New vector test.
 TYPED_TEST(SmallVectorTest, EmptyVectorTest) {
   SCOPED_TRACE("EmptyVectorTest");
   this->assertEmpty(this->theVector);
   EXPECT_TRUE(this->theVector.rbegin() == this->theVector.rend());
   EXPECT_EQ(0, Constructable::getNumConstructorCalls());
   EXPECT_EQ(0, Constructable::getNumDestructorCalls());
 }