addressing most of Casey's comments

Jordan Maples · Jordan Maples · commit 552cd20472e4 · 2020-05-20T10:59:57.000-07:00
diff --git a/include/gsl/span b/include/gsl/span
@@ -420,18 +420,18 @@ public:
     constexpr span() noexcept : storage_(nullptr, details::extent_type<0>())
     {}
 
-     template<std::size_t extent = Extent, std::enable_if_t<extent != gsl::dynamic_extent, int> = 0>
-    constexpr span(pointer ptr, size_type count) noexcept : storage_(ptr, count)
+    template<std::size_t extent = Extent, std::enable_if_t<extent != gsl::dynamic_extent, int> = 0>
+    constexpr explicit span(pointer ptr, size_type count) noexcept : storage_(ptr, count)
     {
         Expects(count == Extent);
     }
 
-     template<std::size_t extent = Extent, std::enable_if_t<extent == gsl::dynamic_extent, int> = 0>
-    constexpr explicit span(pointer ptr, size_type count) noexcept : storage_(ptr, count)
+    template<std::size_t extent = Extent, std::enable_if_t<extent == gsl::dynamic_extent, int> = 0>
+    constexpr span(pointer ptr, size_type count) noexcept : storage_(ptr, count)
     {}
 
     template<std::size_t extent = Extent, std::enable_if_t<extent != gsl::dynamic_extent, int> = 0>
-    constexpr span(pointer firstElem, pointer lastElem) noexcept
+    constexpr explicit span(pointer firstElem, pointer lastElem) noexcept
         : storage_(firstElem, static_cast<std::size_t>(lastElem - firstElem))
     {
         Expects(lastElem - firstElem == static_cast<difference_type>(Extent));
@@ -519,7 +519,7 @@ public:
     constexpr span<element_type, Count> first() const noexcept
     {
         Expects(Count <= size());
-        return {data(), Count};
+        return span<element_type, Count>(data(), Count);
     }
 
     template <std::size_t Count>
@@ -529,7 +529,7 @@ public:
         constexpr span<element_type, Count> last() const noexcept
     {
         Expects(Count <= size());
-        return {data() + (size() - Count), Count};
+        return span<element_type, Count>(data() + (size() - Count), Count);
     }
 
     template <std::size_t Offset, std::size_t Count = dynamic_extent>
@@ -547,7 +547,7 @@ public:
     constexpr span<element_type, dynamic_extent> first(size_type count) const noexcept
     {
         Expects(count <= size());
-        return span<element_type>(data(), count);
+        return {data(), count};
     }
 
     constexpr span<element_type, dynamic_extent> last(size_type count) const noexcept
diff --git a/include/gsl/string_span b/include/gsl/string_span
@@ -121,7 +121,7 @@ span<T, dynamic_extent> ensure_sentinel(T* seq,
     GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute // TODO: suppress does not work
     while (static_cast<std::size_t>(cur - seq) < max && *cur != Sentinel) ++cur;
     Ensures(*cur == Sentinel);
-    return span<T>(seq, static_cast<std::size_t>(cur - seq));
+    return {seq, static_cast<std::size_t>(cur - seq)};
 }
 
 //
diff --git a/tests/span_ext_tests.cpp b/tests/span_ext_tests.cpp
@@ -320,7 +320,7 @@ TEST(span_ext_test, make_span_from_array_constructor)
      {
          int arr[] = {1, 2, 3};
 
-         span<int> s1 = span<int>(&arr[0], 2); // shorter
+         span<int> s1 = {&arr[0], 2}; // shorter
          span<int> s2 = arr;          // longer
 
          EXPECT_TRUE(s1 != s2);
diff --git a/tests/span_tests.cpp b/tests/span_tests.cpp
@@ -157,15 +157,15 @@ TEST(span_test, from_pointer_length_constructor)
         for (int i = 0; i < 4; ++i)
         {
             {
-                span<int> s = span<int>(&arr[0], narrow_cast<std::size_t>(i));
+                span<int> s = {&arr[0], narrow_cast<std::size_t>(i)};
                 EXPECT_TRUE(s.size() == narrow_cast<std::size_t>(i));
                 EXPECT_TRUE(s.data() == &arr[0]);
                 EXPECT_TRUE(s.empty() == (i == 0));
                 for (int j = 0; j < i; ++j)
                     EXPECT_TRUE(arr[j] == s[narrow_cast<std::size_t>(j)]);
             }
             {
-                span<int> s = span<int>(&arr[i], 4 - narrow_cast<std::size_t>(i));
+                span<int> s = {&arr[i], 4 - narrow_cast<std::size_t>(i)};
                 EXPECT_TRUE(s.size() == 4 - narrow_cast<std::size_t>(i));
                 EXPECT_TRUE(s.data() == &arr[i]);
                 EXPECT_TRUE(s.empty() == ((4 - i) == 0));
@@ -678,7 +678,7 @@ TEST(span_test, from_array_constructor)
      s2 = s1;
      EXPECT_TRUE(s2.empty());
 
-     auto get_temp_span = [&]() -> span<int> { return span<int>(&arr[1], 2); };
+     auto get_temp_span = [&]() -> span<int> { return {&arr[1], 2}; };
      auto use_span = [&](span<const int> s) {
          EXPECT_TRUE(s.size() ==  2);
          EXPECT_TRUE(s.data() == &arr[1]);
@@ -1144,7 +1144,7 @@ TEST(span_test, from_array_constructor)
 
      // you can convert statically
      {
-         const span<int, 2> s2 = {&arr[0], 2};
+         const span<int, 2> s2(&arr[0], 2);
          static_cast<void>(s2);
      }
      {
@@ -1180,7 +1180,7 @@ TEST(span_test, from_array_constructor)
  #endif
      {
          auto f = [&]() {
-             const span<int, 4> _s4 = {arr2, 2};
+             const span<int, 4> _s4(arr2, 2);
              static_cast<void>(_s4);
          };
          EXPECT_DEATH(f(), deathstring);
diff --git a/tests/string_span_tests.cpp b/tests/string_span_tests.cpp
@@ -128,7 +128,6 @@ cu16zstring_span<> CreateTempNameU16(u16string_span<> span)
     span[last] = u'\0';
 
     auto ret = span.subspan(0, 4);
-    // return cu16zstring_span<>(ret);
     return {ret};
 }
 
@@ -961,7 +960,7 @@ TEST(string_span_tests, zstring)
         char buf[1];
         buf[0] = '\0';
 
-        zstring_span<> zspan(span<char>(buf, 1));
+        zstring_span<> zspan({buf, 1});
 
         EXPECT_TRUE(generic::strlen(zspan.assume_z()) == 0);
         EXPECT_TRUE(zspan.as_string_span().size() == 0);
@@ -973,7 +972,7 @@ TEST(string_span_tests, zstring)
         char buf[1];
         buf[0] = 'a';
 
-        auto workaround_macro = [&]() { const zstring_span<> zspan(span<char>(buf, 1)); };
+        auto workaround_macro = [&]() { const zstring_span<> zspan({buf, 1}); };
         EXPECT_DEATH(workaround_macro(), deathstring);
     }
 
@@ -1002,7 +1001,7 @@ TEST(string_span_tests, wzstring)
         wchar_t buf[1];
         buf[0] = L'\0';
 
-        wzstring_span<> zspan(span<wchar_t>(buf, 1));
+        wzstring_span<> zspan({buf, 1});
 
         EXPECT_TRUE(generic::strnlen(zspan.assume_z(), 1) == 0);
         EXPECT_TRUE(zspan.as_string_span().size() == 0);
@@ -1014,7 +1013,7 @@ TEST(string_span_tests, wzstring)
         wchar_t buf[1];
         buf[0] = L'a';
 
-        const auto workaround_macro = [&]() { const wzstring_span<> zspan(span<wchar_t>(buf, 1)); };
+        const auto workaround_macro = [&]() { const wzstring_span<> zspan({buf, 1}); };
         EXPECT_DEATH(workaround_macro(), deathstring);
     }
 
@@ -1043,7 +1042,7 @@ TEST(string_span_tests, u16zstring)
         char16_t buf[1];
         buf[0] = L'\0';
 
-        u16zstring_span<> zspan(span<char16_t>(buf, 1));
+        u16zstring_span<> zspan({buf, 1});
 
         EXPECT_TRUE(generic::strnlen(zspan.assume_z(), 1) == 0);
         EXPECT_TRUE(zspan.as_string_span().size() == 0);
@@ -1055,7 +1054,7 @@ TEST(string_span_tests, u16zstring)
         char16_t buf[1];
         buf[0] = u'a';
 
-        const auto workaround_macro = [&]() { const u16zstring_span<> zspan(span<char16_t>(buf, 1)); };
+        const auto workaround_macro = [&]() { const u16zstring_span<> zspan({buf, 1}); };
         EXPECT_DEATH(workaround_macro(), deathstring);
     }
 
@@ -1084,7 +1083,7 @@ TEST(string_span_tests, u32zstring)
         char32_t buf[1];
         buf[0] = L'\0';
 
-        u32zstring_span<> zspan(span<char32_t>(buf, 1));
+        u32zstring_span<> zspan({buf, 1});
 
         EXPECT_TRUE(generic::strnlen(zspan.assume_z(), 1) == 0);
         EXPECT_TRUE(zspan.as_string_span().size() == 0);
@@ -1096,7 +1095,7 @@ TEST(string_span_tests, u32zstring)
         char32_t buf[1];
         buf[0] = u'a';
 
-        const auto workaround_macro = [&]() { const u32zstring_span<> zspan(span<char32_t>(buf, 1)); };
+        const auto workaround_macro = [&]() { const u32zstring_span<> zspan({buf, 1}); };
         EXPECT_DEATH(workaround_macro(), deathstring);
     }
 

Original file line number	Diff line number	Diff line change
`@@ -420,18 +420,18 @@ public:`
`420`	`420`	`constexpr span() noexcept : storage_(nullptr, details::extent_type<0>())`
`421`	`421`	`{}`
`422`	`422`
`423`		`- template<std::size_t extent = Extent, std::enable_if_t<extent != gsl::dynamic_extent, int> = 0>`
`424`		`- constexpr span(pointer ptr, size_type count) noexcept : storage_(ptr, count)`
	`423`	`+ template<std::size_t extent = Extent, std::enable_if_t<extent != gsl::dynamic_extent, int> = 0>`
	`424`	`+ constexpr explicit span(pointer ptr, size_type count) noexcept : storage_(ptr, count)`
`425`	`425`	`{`
`426`	`426`	`Expects(count == Extent);`
`427`	`427`	`}`
`428`	`428`
`429`		`- template<std::size_t extent = Extent, std::enable_if_t<extent == gsl::dynamic_extent, int> = 0>`
`430`		`- constexpr explicit span(pointer ptr, size_type count) noexcept : storage_(ptr, count)`
	`429`	`+ template<std::size_t extent = Extent, std::enable_if_t<extent == gsl::dynamic_extent, int> = 0>`
	`430`	`+ constexpr span(pointer ptr, size_type count) noexcept : storage_(ptr, count)`
`431`	`431`	`{}`
`432`	`432`
`433`	`433`	`template<std::size_t extent = Extent, std::enable_if_t<extent != gsl::dynamic_extent, int> = 0>`
`434`		`- constexpr span(pointer firstElem, pointer lastElem) noexcept`
	`434`	`+ constexpr explicit span(pointer firstElem, pointer lastElem) noexcept`
`435`	`435`	`: storage_(firstElem, static_cast<std::size_t>(lastElem - firstElem))`
`436`	`436`	`{`
`437`	`437`	`Expects(lastElem - firstElem == static_cast<difference_type>(Extent));`
`@@ -519,7 +519,7 @@ public:`
`519`	`519`	`constexpr span<element_type, Count> first() const noexcept`
`520`	`520`	`{`
`521`	`521`	`Expects(Count <= size());`
`522`		`- return {data(), Count};`
	`522`	`+ return span<element_type, Count>(data(), Count);`
`523`	`523`	`}`
`524`	`524`
`525`	`525`	`template <std::size_t Count>`
`@@ -529,7 +529,7 @@ public:`
`529`	`529`	`constexpr span<element_type, Count> last() const noexcept`
`530`	`530`	`{`
`531`	`531`	`Expects(Count <= size());`
`532`		`- return {data() + (size() - Count), Count};`
	`532`	`+ return span<element_type, Count>(data() + (size() - Count), Count);`
`533`	`533`	`}`
`534`	`534`
`535`	`535`	`template <std::size_t Offset, std::size_t Count = dynamic_extent>`
`@@ -547,7 +547,7 @@ public:`
`547`	`547`	`constexpr span<element_type, dynamic_extent> first(size_type count) const noexcept`
`548`	`548`	`{`
`549`	`549`	`Expects(count <= size());`
`550`		`- return span<element_type>(data(), count);`
	`550`	`+ return {data(), count};`
`551`	`551`	`}`
`552`	`552`
`553`	`553`	`constexpr span<element_type, dynamic_extent> last(size_type count) const noexcept`
Original file line number	Diff line number	Diff line change
`@@ -121,7 +121,7 @@ span<T, dynamic_extent> ensure_sentinel(T* seq,`
`121`	`121`	`GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute // TODO: suppress does not work`
`122`	`122`	`while (static_cast<std::size_t>(cur - seq) < max && *cur != Sentinel) ++cur;`
`123`	`123`	`Ensures(*cur == Sentinel);`
`124`		`- return span<T>(seq, static_cast<std::size_t>(cur - seq));`
	`124`	`+ return {seq, static_cast<std::size_t>(cur - seq)};`
`125`	`125`	`}`
`126`	`126`
`127`	`127`	`//`
Original file line number	Diff line number	Diff line change
`@@ -320,7 +320,7 @@ TEST(span_ext_test, make_span_from_array_constructor)`
`320`	`320`	`{`
`321`	`321`	`int arr[] = {1, 2, 3};`
`322`	`322`
`323`		`- span<int> s1 = span<int>(&arr[0], 2); // shorter`
	`323`	`+ span<int> s1 = {&arr[0], 2}; // shorter`
`324`	`324`	`span<int> s2 = arr; // longer`
`325`	`325`
`326`	`326`	`EXPECT_TRUE(s1 != s2);`
Original file line number	Diff line number	Diff line change
`@@ -157,15 +157,15 @@ TEST(span_test, from_pointer_length_constructor)`
`157`	`157`	`for (int i = 0; i < 4; ++i)`
`158`	`158`	`{`
`159`	`159`	`{`
`160`		`- span<int> s = span<int>(&arr[0], narrow_cast<std::size_t>(i));`
	`160`	`+ span<int> s = {&arr[0], narrow_cast<std::size_t>(i)};`
`161`	`161`	`EXPECT_TRUE(s.size() == narrow_cast<std::size_t>(i));`
`162`	`162`	`EXPECT_TRUE(s.data() == &arr[0]);`
`163`	`163`	`EXPECT_TRUE(s.empty() == (i == 0));`
`164`	`164`	`for (int j = 0; j < i; ++j)`
`165`	`165`	`EXPECT_TRUE(arr[j] == s[narrow_cast<std::size_t>(j)]);`
`166`	`166`	`}`
`167`	`167`	`{`
`168`		`- span<int> s = span<int>(&arr[i], 4 - narrow_cast<std::size_t>(i));`
	`168`	`+ span<int> s = {&arr[i], 4 - narrow_cast<std::size_t>(i)};`
`169`	`169`	`EXPECT_TRUE(s.size() == 4 - narrow_cast<std::size_t>(i));`
`170`	`170`	`EXPECT_TRUE(s.data() == &arr[i]);`
`171`	`171`	`EXPECT_TRUE(s.empty() == ((4 - i) == 0));`
`@@ -678,7 +678,7 @@ TEST(span_test, from_array_constructor)`
`678`	`678`	`s2 = s1;`
`679`	`679`	`EXPECT_TRUE(s2.empty());`
`680`	`680`
`681`		`- auto get_temp_span = [&]() -> span<int> { return span<int>(&arr[1], 2); };`
	`681`	`+ auto get_temp_span = [&]() -> span<int> { return {&arr[1], 2}; };`
`682`	`682`	`auto use_span = [&](span<const int> s) {`
`683`	`683`	`EXPECT_TRUE(s.size() == 2);`
`684`	`684`	`EXPECT_TRUE(s.data() == &arr[1]);`
`@@ -1144,7 +1144,7 @@ TEST(span_test, from_array_constructor)`
`1144`	`1144`
`1145`	`1145`	`// you can convert statically`
`1146`	`1146`	`{`
`1147`		`- const span<int, 2> s2 = {&arr[0], 2};`
	`1147`	`+ const span<int, 2> s2(&arr[0], 2);`
`1148`	`1148`	`static_cast<void>(s2);`
`1149`	`1149`	`}`
`1150`	`1150`	`{`
`@@ -1180,7 +1180,7 @@ TEST(span_test, from_array_constructor)`
`1180`	`1180`	`#endif`
`1181`	`1181`	`{`
`1182`	`1182`	`auto f = [&]() {`
`1183`		`- const span<int, 4> _s4 = {arr2, 2};`
	`1183`	`+ const span<int, 4> _s4(arr2, 2);`
`1184`	`1184`	`static_cast<void>(_s4);`
`1185`	`1185`	`};`
`1186`	`1186`	`EXPECT_DEATH(f(), deathstring);`