Added library.json

2020-10-28 01:10:25 +01:00
36 changed files with 911 additions and 1261 deletions
@@ -1,8 +1,5 @@
 cmake_minimum_required(VERSION 3.1.3...3.16)

-list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/")
-include(guidelineSupportLibrary)
-
 project(GSL VERSION 3.1.0 LANGUAGES CXX)

 include(ExternalProject)
@@ -11,30 +8,39 @@ find_package(Git)
 # Use GNUInstallDirs to provide the right locations on all platforms
 include(GNUInstallDirs)

-# Creates a library GSL which is an interface (header files only)
+# creates a library GSL which is an interface (header files only)
 add_library(GSL INTERFACE)

-# NOTE: If you want to use GSL prefer to link against GSL using this alias target
-# EX:
-#   target_link_libraries(foobar PRIVATE Microsoft.GSL::GSL)
-#
-# Add Microsoft.GSL::GSL alias for GSL so that dependents can be agnostic about
-# whether GSL was added via `add_subdirectory` or `find_package`
-add_library(Microsoft.GSL::GSL ALIAS GSL)
-
-# Determine whether this is a standalone project or included by other projects
+# determine whether this is a standalone project or included by other projects
 set(GSL_STANDALONE_PROJECT OFF)
 if (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
    set(GSL_STANDALONE_PROJECT ON)
+endif ()
+
+set(GSL_CXX_STANDARD "14" CACHE STRING "Use c++ standard")
+set(GSL_CXX_STD "cxx_std_${GSL_CXX_STANDARD}")
+
+if (MSVC)
+    set(GSL_CXX_STD_OPT "-std:c++${GSL_CXX_STANDARD}")
+else()
+    set(GSL_CXX_STD_OPT "-std=c++${GSL_CXX_STANDARD}")
 endif()

-# This GSL implementation generally assumes a platform that implements C++14 support.
-set(gsl_min_cxx_standard "14")
+# when minimum version required is 3.8.0 remove if below
+# both branches do exactly the same thing
+if (CMAKE_VERSION VERSION_LESS 3.7.9)
+    include(CheckCXXCompilerFlag)
+    CHECK_CXX_COMPILER_FLAG("${GSL_CXX_STD_OPT}" COMPILER_SUPPORTS_CXX_STANDARD)

-if (GSL_STANDALONE_PROJECT)
-    gsl_set_default_cxx_standard(${gsl_min_cxx_standard})
-else()
-    gsl_client_set_cxx_standard(${gsl_min_cxx_standard})
+    if(COMPILER_SUPPORTS_CXX_STANDARD)
+        target_compile_options(GSL INTERFACE "${GSL_CXX_STD_OPT}")
+    else()
+        message(FATAL_ERROR "The compiler ${CMAKE_CXX_COMPILER} has no c++${GSL_CXX_STANDARD} support. Please use a different C++ compiler.")
+    endif()
+else ()
+    target_compile_features(GSL INTERFACE "${GSL_CXX_STD}")
+    # on *nix systems force the use of -std=c++XX instead of -std=gnu++XX (default)
+    set(CMAKE_CXX_EXTENSIONS OFF)
 endif()

 # add definitions to the library and targets that consume it
@@ -105,6 +111,10 @@ else()
 endif()
 install(FILES ${CMAKE_CURRENT_BINARY_DIR}/Microsoft.GSLConfigVersion.cmake DESTINATION ${CMAKE_INSTALL_DATADIR}/cmake/Microsoft.GSL)

+# Add Microsoft.GSL::GSL alias for GSL so that dependents can be agnostic about
+# whether GSL was added via `add_subdirectory` or `find_package`
+add_library(Microsoft.GSL::GSL ALIAS GSL)
+
 option(GSL_TEST "Generate tests." ${GSL_STANDALONE_PROJECT})
 if (GSL_TEST)
    enable_testing()
@@ -1,5 +1,5 @@
 # GSL: Guidelines Support Library
-[![Build Status](https://dev.azure.com/cppstat/GSL/_apis/build/status/microsoft.GSL?branchName=master)](https://dev.azure.com/cppstat/GSL/_build/latest?definitionId=1&branchName=master)
+[![Build Status](https://travis-ci.org/Microsoft/GSL.svg?branch=master)](https://travis-ci.org/Microsoft/GSL) [![Build status](https://ci.appveyor.com/api/projects/status/github/Microsoft/GSL?svg=true)](https://ci.appveyor.com/project/neilmacintosh/GSL)

 The Guidelines Support Library (GSL) contains functions and types that are suggested for use by the
 [C++ Core Guidelines](https://github.com/isocpp/CppCoreGuidelines) maintained by the [Standard C++ Foundation](https://isocpp.org).
@@ -29,23 +29,14 @@ owner                              | &#x2611;   | an alias for a raw pointer
 not_null                           | &#x2611;   | restricts a pointer / smart pointer to hold non-null values
 span                               | &#x2611;   | a view over a contiguous sequence of memory. Based on the standardized verison of `std::span`, however `gsl::span` enforces bounds checking. See the [wiki](https://github.com/microsoft/GSL/wiki/gsl::span-and-std::span) for additional information.
 span_p                             | &#x2610;   | spans a range starting from a pointer to the first place for which the predicate is true
-basic_zstring                      | &#x2611;   | A pointer to a C-string (zero-terminated array) with a templated char type
-zstring                            | &#x2611;   | An alias to `basic_zstring` with a char type of char
-czstring                           | &#x2611;   | An alias to `basic_zstring` with a char type of const char
-wzstring                           | &#x2611;   | An alias to `basic_zstring` with a char type of wchar_t
-cwzstring                          | &#x2611;   | An alias to `basic_zstring` with a char type of const wchar_t
-u16zstring                         | &#x2611;   | An alias to `basic_zstring` with a char type of char16_t
-cu16zstring                        | &#x2611;   | An alias to `basic_zstring` with a char type of const char16_t
-u32zstring                         | &#x2611;   | An alias to `basic_zstring` with a char type of char32_t
-cu32zstring                        | &#x2611;   | An alias to `basic_zstring` with a char type of const char32_t
 [**2. Owners**][cg-owners]         |            |
 unique_ptr                         | &#x2611;   | an alias to `std::unique_ptr`
 shared_ptr                         | &#x2611;   | an alias to `std::shared_ptr`
 stack_array                        | &#x2610;   | a stack-allocated array
 dyn_array                          | &#x2610;   | a heap-allocated array
 [**3. Assertions**][cg-assertions] |            |
-Expects                            | &#x2611;   | a precondition assertion; on failure it terminates by default if no user-installed handler
-Ensures                            | &#x2611;   | a postcondition assertion; on failure it terminates by default if no user-installed handler
+Expects                            | &#x2611;   | a precondition assertion; on failure it terminates
+Ensures                            | &#x2611;   | a postcondition assertion; on failure it terminates
 [**4. Utilities**][cg-utilities]   |            |
 move_owner                         | &#x2610;   | a helper function that moves one `owner` to the other
 byte                               | &#x2611;   | either an alias to std::byte or a byte type
@@ -66,6 +57,15 @@ Feature                            | Supported? | Description
 strict_not_null                    | &#x2611;   | A stricter version of `not_null` with explicit constructors
 multi_span                         | &#x2610;   | Deprecated. Multi-dimensional span.
 strided_span                       | &#x2610;   | Deprecated. Support for this type has been discontinued.
+basic_zstring                      | &#x2610;   | Deprecated. A pointer to a C-string (zero-terminated array) with a templated char type
+zstring                            | &#x2610;   | Deprecated. An alias to `basic_zstring` with a char type of char
+czstring                           | &#x2610;   | Deprecated. An alias to `basic_zstring` with a char type of const char
+wzstring                           | &#x2610;   | Deprecated. An alias to `basic_zstring` with a char type of wchar_t
+cwzstring                          | &#x2610;   | Deprecated. An alias to `basic_zstring` with a char type of const wchar_t
+u16zstring                         | &#x2610;   | Deprecated. An alias to `basic_zstring` with a char type of char16_t
+cu16zstring                        | &#x2610;   | Deprecated. An alias to `basic_zstring` with a char type of const char16_t
+u32zstring                         | &#x2610;   | Deprecated. An alias to `basic_zstring` with a char type of char32_t
+cu32zstring                        | &#x2610;   | Deprecated. An alias to `basic_zstring` with a char type of const char32_t
 basic_string_span                  | &#x2610;   | Deprecated. Like `span` but for strings with a templated char type
 string_span                        | &#x2610;   | Deprecated. An alias to `basic_string_span` with a char type of char
 cstring_span                       | &#x2610;   | Deprecated. An alias to `basic_string_span` with a char type of const char
@@ -89,13 +89,16 @@ This is based on [CppCoreGuidelines semi-specification](https://github.com/isocp
 The GSL officially supports the current and previous major release of MSVC, GCC, Clang, and XCode's Apple-Clang.
 See our latest test results for the most up-to-date list of supported configurations.

-Compiler |Toolset Versions Currently Tested
-:------- |--:
- XCode |11.4 & 10.3
- GCC |9 & 8
- Clang |11 &  10
- Visual Studio with MSVC | VS2017 (15.9) & VS2019 (16.4) 
- Visual Studio with LLVM | VS2017 (Clang 9) & VS2019 (Clang 10)
+Compiler |Toolset Versions Currently Tested| Build Status
+:------- |:--|------------:
+ XCode |11.4 & 10.3 | [![Status](https://travis-ci.org/Microsoft/GSL.svg?branch=master)](https://travis-ci.org/Microsoft/GSL)
+ GCC |9 & 8| [![Status](https://travis-ci.org/Microsoft/GSL.svg?branch=master)](https://travis-ci.org/Microsoft/GSL)
+ Clang |11 &  10| [![Status](https://travis-ci.org/Microsoft/GSL.svg?branch=master)](https://travis-ci.org/Microsoft/GSL)
+ Visual Studio with MSVC | VS2017 (15.9) & VS2019 (16.4) | [![Status](https://ci.appveyor.com/api/projects/status/github/Microsoft/GSL?svg=true)](https://ci.appveyor.com/project/neilmacintosh/GSL)
+ Visual Studio with LLVM | VS2017 (Clang 9) & VS2019 (Clang 10) | [![Status](https://ci.appveyor.com/api/projects/status/github/Microsoft/GSL?svg=true)](https://ci.appveyor.com/project/neilmacintosh/GSL)
+
+
+Note: For `gsl::byte` to work correctly with Clang and GCC you might have to use the ` -fno-strict-aliasing` compiler option.

 ---
 If you successfully port GSL to another platform, we would love to hear from you!
@@ -1,68 +0,0 @@
-trigger:
-  - master
-
-pr:
-  autoCancel: true
-
-# GCC
-stages:
- stage: GCC
-  dependsOn: []
-  variables:
-  - name: CC
-    value: gcc
-  - name: CXX
-    value: g++
-  jobs:
-  - template: ./pipelines/jobs.yml
-    parameters:
-      jobName: 'Validate GCC latest'
-      imageName: ubuntu-20.04
-  - template: ./pipelines/jobs.yml
-    parameters:
-      jobName: 'Validate GCC Previous'
-      imageName: ubuntu-18.04
-
-# Clang
- stage: Clang
-  dependsOn: []
-  variables:
-  - name: CC
-    value: clang
-  - name: CXX
-    value: clang++
-  jobs:
-  - template: ./pipelines/jobs.yml
-    parameters:
-      jobName: 'Validate Clang latest'
-      imageName: ubuntu-20.04
-  - template: ./pipelines/jobs.yml
-    parameters:
-      jobName: 'Validate Clang Previous'
-      imageName: ubuntu-18.04
-
-# MSVC
- stage: MSVC
-  dependsOn: []
-  jobs:
-  - template: ./pipelines/jobs.yml
-    parameters:
-      jobName: 'Validate MSVC latest'
-      imageName: windows-latest
-  - template: ./pipelines/jobs.yml
-    parameters:
-      jobName: 'Validate MSVC Previous'
-      imageName: vs2017-win2016
-
-# Apple-Clang
- stage: Apple_Clang
-  dependsOn: []
-  jobs:
-  - template: ./pipelines/jobs.yml
-    parameters:
-      jobName: 'Validate Apple-Clang latest'
-      imageName: macos-10.15
-  - template: ./pipelines/jobs.yml
-    parameters:
-      jobName: 'Validate Apple-Clang Previous'
-      imageName: macos-10.14
@@ -1,61 +0,0 @@
-# This cmake module is meant to hold helper functions/macros
-# that make maintaining the cmake build system much easier.
-# This is especially helpful since gsl needs to provide coverage
-# for multiple versions of cmake.
-#
-# Any functions/macros should have a gsl_* prefix to avoid problems
-if (DEFINED guideline_support_library_include_guard)
-    return()
-endif()
-set(guideline_support_library_include_guard ON)
-
-function(gsl_set_default_cxx_standard min_cxx_standard)
-    set(GSL_CXX_STANDARD "${min_cxx_standard}" CACHE STRING "Use c++ standard")
-
-    set(GSL_CXX_STD "cxx_std_${GSL_CXX_STANDARD}")
-
-    if (MSVC)
-        set(GSL_CXX_STD_OPT "-std:c++${GSL_CXX_STANDARD}")
-    else()
-        set(GSL_CXX_STD_OPT "-std=c++${GSL_CXX_STANDARD}")
-    endif()
-
-    # when minimum version required is 3.8.0 remove if below
-    # both branches do exactly the same thing
-    if (CMAKE_VERSION VERSION_LESS 3.7.9)
-        include(CheckCXXCompilerFlag)
-        CHECK_CXX_COMPILER_FLAG("${GSL_CXX_STD_OPT}" COMPILER_SUPPORTS_CXX_STANDARD)
-
-        if(COMPILER_SUPPORTS_CXX_STANDARD)
-            target_compile_options(GSL INTERFACE "${GSL_CXX_STD_OPT}")
-        else()
-            message(FATAL_ERROR "The compiler ${CMAKE_CXX_COMPILER} has no c++${GSL_CXX_STANDARD} support. Please use a different C++ compiler.")
-        endif()
-    else()
-        target_compile_features(GSL INTERFACE "${GSL_CXX_STD}")
-        # on *nix systems force the use of -std=c++XX instead of -std=gnu++XX (default)
-        set(CMAKE_CXX_EXTENSIONS OFF)
-    endif()
-endfunction()
-
-# The best way for a project to specify the GSL's C++ standard is by the client specifying
-# the CMAKE_CXX_STANDARD. However, this isn't always ideal. Since the CMAKE_CXX_STANDARD is
-# tied to the cmake version. And many projects have low cmake minimums.
-#
-# So provide an alternative approach in case that doesn't work.
-function(gsl_client_set_cxx_standard min_cxx_standard)
-    if (DEFINED CMAKE_CXX_STANDARD)
-        if (${CMAKE_CXX_STANDARD} VERSION_LESS ${min_cxx_standard})
-            message(FATAL_ERROR "GSL: Requires at least CXX standard ${min_cxx_standard}, user provided ${CMAKE_CXX_STANDARD}")
-        endif()
-
-        # Set the GSL standard to what the client desires
-        set(GSL_CXX_STANDARD "${CMAKE_CXX_STANDARD}" PARENT_SCOPE)
-
-        # Exit out early to avoid extra unneccessary work
-        return()
-    endif()
-
-    # Otherwise pick a reasonable default
-    gsl_set_default_cxx_standard(${min_cxx_standard})
-endfunction()
@@ -1,63 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
-//
-// This code is licensed under the MIT License (MIT).
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef GSL_ALGORITHM_H
-#define GSL_ALGORITHM_H
-
-#include <gsl/assert> // for contracts
-#include <gsl/span>   // for dynamic_extent, span
-
-#include <algorithm>   // for copy_n
-#include <cstddef>     // for ptrdiff_t
-#include <type_traits> // for is_assignable
-
-#ifdef _MSC_VER
-#pragma warning(push)
-
-// turn off some warnings that are noisy about our contract checks
-#pragma warning(disable : 4127) // conditional expression is constant
-#pragma warning(disable : 4996) // unsafe use of std::copy_n
-
-#endif // _MSC_VER
-
-namespace gsl
-{
-// Note: this will generate faster code than std::copy using span iterator in older msvc+stl
-// not necessary for msvc since VS2017 15.8 (_MSC_VER >= 1915)
-template <class SrcElementType, std::size_t SrcExtent, class DestElementType,
-          std::size_t DestExtent>
-void copy(span<SrcElementType, SrcExtent> src, span<DestElementType, DestExtent> dest)
-{
-    static_assert(std::is_assignable<decltype(*dest.data()), decltype(*src.data())>::value,
-                  "Elements of source span can not be assigned to elements of destination span");
-    static_assert(SrcExtent == dynamic_extent || DestExtent == dynamic_extent ||
-                      (SrcExtent <= DestExtent),
-                  "Source range is longer than target range");
-
-    Expects(dest.size() >= src.size(), Bounds);
-    // clang-format off
-    GSL_SUPPRESS(stl.1) // NO-FORMAT: attribute
-    // clang-format on
-    std::copy_n(src.data(), src.size(), dest.data());
-}
-
-} // namespace gsl
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif // _MSC_VER
-
-#endif // GSL_ALGORITHM_H
@@ -1,149 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
-//
-// This code is licensed under the MIT License (MIT).
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef GSL_CONTRACTS_H
-#define GSL_CONTRACTS_H
-
-
-//
-// Temporary until MSVC STL supports no-exceptions mode.
-// Currently terminate is a no-op in this mode, so we add termination behavior back
-//
-#if defined(_MSC_VER) && (defined(_KERNEL_MODE) || (defined(_HAS_EXCEPTIONS) && !_HAS_EXCEPTIONS))
-
-#define GSL_MSVC_USE_STL_NOEXCEPTION_WORKAROUND
-#include <intrin.h>
-#define RANGE_CHECKS_FAILURE 0
-
-#if defined(__clang__)
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Winvalid-noreturn"
-#endif // defined(__clang__)
-
-#else // defined(_MSC_VER) && (defined(_KERNEL_MODE) || (defined(_HAS_EXCEPTIONS) &&
-      // !_HAS_EXCEPTIONS))
-
-#include <exception>
-
-#endif // defined(_MSC_VER) && (defined(_KERNEL_MODE) || (defined(_HAS_EXCEPTIONS) &&
-       // !_HAS_EXCEPTIONS))
-
-//
-// make suppress attributes parse for some compilers
-// Hopefully temporary until suppression standardization occurs
-//
-#if defined(__clang__)
-#define GSL_SUPPRESS(x) [[gsl::suppress("x")]]
-#else
-#if defined(_MSC_VER) && !defined(__INTEL_COMPILER)
-#define GSL_SUPPRESS(x) [[gsl::suppress(x)]]
-#else
-#define GSL_SUPPRESS(x)
-#endif // _MSC_VER
-#endif // __clang__
-
-#define GSL_STRINGIFY_DETAIL(x) #x
-#define GSL_STRINGIFY(x) GSL_STRINGIFY_DETAIL(x)
-
-//
-// GSL.assert: assertions
-//
-
-namespace gsl
-{
-
-namespace details
-{
-#if defined(GSL_MSVC_USE_STL_NOEXCEPTION_WORKAROUND)
-
-    typedef void(__cdecl* terminate_handler)();
-
-    // clang-format off
-    GSL_SUPPRESS(f.6) // NO-FORMAT: attribute
-    // clang-format on
-    [[noreturn]] inline void __cdecl default_terminate_handler()
-    {
-        __fastfail(RANGE_CHECKS_FAILURE);
-    }
-
-    inline gsl::details::terminate_handler& get_terminate_handler() noexcept
-    {
-        static terminate_handler handler = &default_terminate_handler;
-        return handler;
-    }
-
-#endif // defined(GSL_MSVC_USE_STL_NOEXCEPTION_WORKAROUND)
-
-    [[noreturn]] inline void terminate() noexcept
-    {
-#if defined(GSL_MSVC_USE_STL_NOEXCEPTION_WORKAROUND)
-        (*gsl::details::get_terminate_handler())();
-#else
-        std::terminate();
-#endif // defined(GSL_MSVC_USE_STL_NOEXCEPTION_WORKAROUND)
-    }
-
-} // namespace details
-
-
-class contract_group {
-public:
-#if defined __cpp_noexcept_function_type
-    using handler = void (*)() noexcept;
-#else // VESTIGIAL, remove when no longer needed for downlevel compilers
-    using handler = void (*)();
-#endif
-    constexpr contract_group  (handler h = nullptr)  : chandler(normalize(h)) { }
-    constexpr auto set_handler(handler h) -> handler { auto old = chandler; chandler = normalize(h); return old; }
-    constexpr auto get_handler() const    -> handler { return chandler; }
-    constexpr auto expects  (bool b)      -> void    { assertion(b); }
-    constexpr auto ensures  (bool b)      -> void    { assertion(b); }
-private:
-    constexpr auto assertion(bool b)      -> void    { if (!b) chandler(); }
-    constexpr auto normalize(handler h)   -> handler { return h ? h : []()noexcept{}; }
-    handler chandler;
-};
-
-// By default, there is one violation handler per translation unit.
-// Defining GSL_GLOBAL_CONTRACT_VIOLATION_HANDLERS and compiling as
-// C++17 (or later) opts into using a global violation handler.
-#if defined GSL_GLOBAL_CONTRACT_VIOLATION_HANDLERS && __cplusplus >= 201703L
-#define GSL_CONTRACT_VIOLATION_GRANULARITY inline
-#else
-#define GSL_CONTRACT_VIOLATION_GRANULARITY static
-#endif
-
-auto GSL_CONTRACT_VIOLATION_GRANULARITY Default = contract_group( 
-#if defined GSL_UNENFORCED_ON_CONTRACT_VIOLATION
-                                      // use default == null handler
-#else // if defined GSL_TERMINATE_ON_CONTRACT_VIOLATION
-                                      &gsl::details::terminate
-#endif
-                                    );
-auto GSL_CONTRACT_VIOLATION_GRANULARITY Bounds  = Default;
-auto GSL_CONTRACT_VIOLATION_GRANULARITY Null    = Default;
-auto GSL_CONTRACT_VIOLATION_GRANULARITY Testing = Default;
-
-} // namespace gsl
-
-#define Expects(cond, kind) kind.expects(cond)
-#define Ensures(cond, kind) kind.ensures(cond)
-
-#if defined(GSL_MSVC_USE_STL_NOEXCEPTION_WORKAROUND) && defined(__clang__)
-#pragma clang diagnostic pop
-#endif
-
-#endif // GSL_CONTRACTS_H
@@ -1,213 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
-//
-// This code is licensed under the MIT License (MIT).
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef GSL_BYTE_H
-#define GSL_BYTE_H
-
-//
-// make suppress attributes work for some compilers
-// Hopefully temporary until suppression standardization occurs
-//
-#if defined(__clang__)
-#define GSL_SUPPRESS(x) [[gsl::suppress("x")]]
-#else
-#if defined(_MSC_VER) && !defined(__INTEL_COMPILER)
-#define GSL_SUPPRESS(x) [[gsl::suppress(x)]]
-#else
-#define GSL_SUPPRESS(x)
-#endif // _MSC_VER
-#endif // __clang__
-
-#include <type_traits>
-
-// VS2017 15.8 added support for the __cpp_lib_byte definition
-// To do: drop _HAS_STD_BYTE when support for pre 15.8 expires
-#ifdef _MSC_VER
-
-#pragma warning(push)
-
-// Turn MSVC /analyze rules that generate too much noise. TODO: fix in the tool.
-#pragma warning(disable : 26493) // don't use c-style casts // TODO: MSVC suppression in templates
-                                 // does not always work
-
-#ifndef GSL_USE_STD_BYTE
-// this tests if we are under MSVC and the standard lib has std::byte and it is enabled
-#if (defined(_HAS_STD_BYTE) && _HAS_STD_BYTE) ||                                                   \
-    (defined(__cpp_lib_byte) && __cpp_lib_byte >= 201603)
-
-#define GSL_USE_STD_BYTE 1
-
-#else // (defined(_HAS_STD_BYTE) && _HAS_STD_BYTE) || (defined(__cpp_lib_byte) && __cpp_lib_byte >=
-      // 201603)
-
-#define GSL_USE_STD_BYTE 0
-
-#endif // (defined(_HAS_STD_BYTE) && _HAS_STD_BYTE) || (defined(__cpp_lib_byte) && __cpp_lib_byte >=
-       // 201603)
-#endif // GSL_USE_STD_BYTE
-
-#else // _MSC_VER
-
-#ifndef GSL_USE_STD_BYTE
-#include <cstddef> /* __cpp_lib_byte */
-// this tests if we are under GCC or Clang with enough -std=c++1z power to get us std::byte
-// also check if libc++ version is sufficient (> 5.0) or libstdc++ actually contains std::byte
-#if defined(__cplusplus) && (__cplusplus >= 201703L) &&                                            \
-    (defined(__cpp_lib_byte) && (__cpp_lib_byte >= 201603) ||                                      \
-     defined(_LIBCPP_VERSION) && (_LIBCPP_VERSION >= 5000))
-
-#define GSL_USE_STD_BYTE 1
-
-#else // defined(__cplusplus) && (__cplusplus >= 201703L) &&
-      //   (defined(__cpp_lib_byte) && (__cpp_lib_byte >= 201603)  ||
-      //    defined(_LIBCPP_VERSION) && (_LIBCPP_VERSION >= 5000))
-
-#define GSL_USE_STD_BYTE 0
-
-#endif // defined(__cplusplus) && (__cplusplus >= 201703L) &&
-       //   (defined(__cpp_lib_byte) && (__cpp_lib_byte >= 201603)  ||
-       //    defined(_LIBCPP_VERSION) && (_LIBCPP_VERSION >= 5000))
-#endif // GSL_USE_STD_BYTE
-
-#endif // _MSC_VER
-
-// Use __may_alias__ attribute on gcc and clang
-#if defined __clang__ || (defined(__GNUC__) && __GNUC__ > 5)
-#define byte_may_alias __attribute__((__may_alias__))
-#else // defined __clang__ || defined __GNUC__
-#define byte_may_alias
-#endif // defined __clang__ || defined __GNUC__
-
-#if GSL_USE_STD_BYTE
-#include <cstddef>
-#endif
-
-namespace gsl
-{
-#if GSL_USE_STD_BYTE
-
-using std::byte;
-using std::to_integer;
-
-#else // GSL_USE_STD_BYTE
-
-// This is a simple definition for now that allows
-// use of byte within span<> to be standards-compliant
-enum class byte_may_alias byte : unsigned char
-{
-};
-
-template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
-constexpr byte& operator<<=(byte& b, IntegerType shift) noexcept
-{
-    return b = byte(static_cast<unsigned char>(b) << shift);
-}
-
-template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
-constexpr byte operator<<(byte b, IntegerType shift) noexcept
-{
-    return byte(static_cast<unsigned char>(b) << shift);
-}
-
-template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
-constexpr byte& operator>>=(byte& b, IntegerType shift) noexcept
-{
-    return b = byte(static_cast<unsigned char>(b) >> shift);
-}
-
-template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
-constexpr byte operator>>(byte b, IntegerType shift) noexcept
-{
-    return byte(static_cast<unsigned char>(b) >> shift);
-}
-
-constexpr byte& operator|=(byte& l, byte r) noexcept
-{
-    return l = byte(static_cast<unsigned char>(l) | static_cast<unsigned char>(r));
-}
-
-constexpr byte operator|(byte l, byte r) noexcept
-{
-    return byte(static_cast<unsigned char>(l) | static_cast<unsigned char>(r));
-}
-
-constexpr byte& operator&=(byte& l, byte r) noexcept
-{
-    return l = byte(static_cast<unsigned char>(l) & static_cast<unsigned char>(r));
-}
-
-constexpr byte operator&(byte l, byte r) noexcept
-{
-    return byte(static_cast<unsigned char>(l) & static_cast<unsigned char>(r));
-}
-
-constexpr byte& operator^=(byte& l, byte r) noexcept
-{
-    return l = byte(static_cast<unsigned char>(l) ^ static_cast<unsigned char>(r));
-}
-
-constexpr byte operator^(byte l, byte r) noexcept
-{
-    return byte(static_cast<unsigned char>(l) ^ static_cast<unsigned char>(r));
-}
-
-constexpr byte operator~(byte b) noexcept { return byte(~static_cast<unsigned char>(b)); }
-
-template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
-constexpr IntegerType to_integer(byte b) noexcept
-{
-    return static_cast<IntegerType>(b);
-}
-
-#endif // GSL_USE_STD_BYTE
-
-template <bool E, typename T>
-constexpr byte to_byte_impl(T t) noexcept
-{
-    static_assert(
-        E, "gsl::to_byte(t) must be provided an unsigned char, otherwise data loss may occur. "
-           "If you are calling to_byte with an integer contant use: gsl::to_byte<t>() version.");
-    return static_cast<byte>(t);
-}
-template <>
-// NOTE: need suppression since c++14 does not allow "return {t}"
-// GSL_SUPPRESS(type.4) // NO-FORMAT: attribute // TODO: suppression does not work
-constexpr byte to_byte_impl<true, unsigned char>(unsigned char t) noexcept
-{
-    return byte(t);
-}
-
-template <typename T>
-constexpr byte to_byte(T t) noexcept
-{
-    return to_byte_impl<std::is_same<T, unsigned char>::value, T>(t);
-}
-
-template <int I>
-constexpr byte to_byte() noexcept
-{
-    static_assert(I >= 0 && I <= 255,
-                  "gsl::byte only has 8 bits of storage, values must be in range 0-255");
-    return static_cast<byte>(I);
-}
-
-} // namespace gsl
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif // _MSC_VER
-
-#endif // GSL_BYTE_H
@@ -17,17 +17,13 @@
 #ifndef GSL_GSL_H
 #define GSL_GSL_H

-#include <gsl/algorithm>   // copy
-#include <gsl/assert>      // contracts
-#include <gsl/byte>        // byte
-#include <gsl/pointers>    // owner, not_null
-#include <gsl/multi_span>  // multi_span, strided_span...
-#include <gsl/span>        // span
-#include <gsl/string_span> // zstring, string_span, zstring_builder...
-#include <gsl/util>        // finally()/narrow_cast()...
-
-#ifdef __cpp_exceptions
-#include <gsl/narrow> // narrow()
-#endif
+#include <gsl/gsl_algorithm> // copy
+#include <gsl/gsl_assert>    // Ensures/Expects
+#include <gsl/gsl_byte>      // byte
+#include <gsl/gsl_util>      // finally()/narrow()/narrow_cast()...
+#include <gsl/multi_span>    // multi_span, strided_span...
+#include <gsl/pointers>      // owner, not_null
+#include <gsl/span>          // span
+#include <gsl/string_span>   // zstring, string_span, zstring_builder...

 #endif // GSL_GSL_H
@@ -1,3 +1,61 @@
-#pragma once
-#pragma message("This header will soon be removed. Use <gsl/algorithm> instead of <gsl/gsl_algorithm>")
-#include <gsl/algorithm>
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
+//
+// This code is licensed under the MIT License (MIT).
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef GSL_ALGORITHM_H
+#define GSL_ALGORITHM_H
+
+#include <gsl/gsl_assert> // for Expects
+#include <gsl/span>       // for dynamic_extent, span
+
+#include <algorithm>   // for copy_n
+#include <cstddef>     // for ptrdiff_t
+#include <type_traits> // for is_assignable
+
+#ifdef _MSC_VER
+#pragma warning(push)
+
+// turn off some warnings that are noisy about our Expects statements
+#pragma warning(disable : 4127) // conditional expression is constant
+#pragma warning(disable : 4996) // unsafe use of std::copy_n
+
+#endif // _MSC_VER
+
+namespace gsl
+{
+// Note: this will generate faster code than std::copy using span iterator in older msvc+stl
+// not necessary for msvc since VS2017 15.8 (_MSC_VER >= 1915)
+template <class SrcElementType, std::size_t SrcExtent, class DestElementType,
+          std::size_t DestExtent>
+void copy(span<SrcElementType, SrcExtent> src, span<DestElementType, DestExtent> dest)
+{
+    static_assert(std::is_assignable<decltype(*dest.data()), decltype(*src.data())>::value,
+                  "Elements of source span can not be assigned to elements of destination span");
+    static_assert(SrcExtent == dynamic_extent || DestExtent == dynamic_extent ||
+                      (SrcExtent <= DestExtent),
+                  "Source range is longer than target range");
+
+    Expects(dest.size() >= src.size());
+    GSL_SUPPRESS(stl.1) // NO-FORMAT: attribute
+    std::copy_n(src.data(), src.size(), dest.data());
+}
+
+} // namespace gsl
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif // _MSC_VER
+
+#endif // GSL_ALGORITHM_H
@@ -1,3 +1,133 @@
-#pragma once
-#pragma message("This header will soon be removed. Use <gsl/assert> instead of <gsl/gsl_assert>")
-#include <gsl/assert>
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
+//
+// This code is licensed under the MIT License (MIT).
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef GSL_CONTRACTS_H
+#define GSL_CONTRACTS_H
+
+//
+// Temporary until MSVC STL supports no-exceptions mode.
+// Currently terminate is a no-op in this mode, so we add termination behavior back
+//
+#if defined(_MSC_VER) && (defined(_KERNEL_MODE) || (defined(_HAS_EXCEPTIONS) && !_HAS_EXCEPTIONS))
+
+#define GSL_MSVC_USE_STL_NOEXCEPTION_WORKAROUND
+#include <intrin.h>
+#define RANGE_CHECKS_FAILURE 0
+
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Winvalid-noreturn"
+#endif // defined(__clang__)
+
+#else // defined(_MSC_VER) && (defined(_KERNEL_MODE) || (defined(_HAS_EXCEPTIONS) && !_HAS_EXCEPTIONS))
+
+#include <exception>
+
+#endif // defined(_MSC_VER) && (defined(_KERNEL_MODE) || (defined(_HAS_EXCEPTIONS) && !_HAS_EXCEPTIONS))
+
+//
+// make suppress attributes parse for some compilers
+// Hopefully temporary until suppression standardization occurs
+//
+#if defined(__clang__)
+#define GSL_SUPPRESS(x) [[gsl::suppress("x")]]
+#else
+#if defined(_MSC_VER) && ! defined(__INTEL_COMPILER)
+#define GSL_SUPPRESS(x) [[gsl::suppress(x)]]
+#else
+#define GSL_SUPPRESS(x)
+#endif // _MSC_VER
+#endif // __clang__
+
+#define GSL_STRINGIFY_DETAIL(x) #x
+#define GSL_STRINGIFY(x) GSL_STRINGIFY_DETAIL(x)
+
+#if defined(__clang__) || defined(__GNUC__)
+#define GSL_LIKELY(x) __builtin_expect(!!(x), 1)
+#define GSL_UNLIKELY(x) __builtin_expect(!!(x), 0)
+
+#else
+
+#define GSL_LIKELY(x) (!!(x))
+#define GSL_UNLIKELY(x) (!!(x))
+#endif // defined(__clang__) || defined(__GNUC__)
+
+//
+// GSL_ASSUME(cond)
+//
+// Tell the optimizer that the predicate cond must hold. It is unspecified
+// whether or not cond is actually evaluated.
+//
+#ifdef _MSC_VER
+#define GSL_ASSUME(cond) __assume(cond)
+#elif defined(__GNUC__)
+#define GSL_ASSUME(cond) ((cond) ? static_cast<void>(0) : __builtin_unreachable())
+#else
+#define GSL_ASSUME(cond) static_cast<void>((cond) ? 0 : 0)
+#endif
+
+//
+// GSL.assert: assertions
+//
+
+namespace gsl
+{
+
+namespace details
+{
+#if defined(GSL_MSVC_USE_STL_NOEXCEPTION_WORKAROUND)
+
+    typedef void(__cdecl* terminate_handler)();
+
+    // clang-format off
+    GSL_SUPPRESS(f.6) // NO-FORMAT: attribute
+    // clang-format on
+    [[noreturn]] inline void __cdecl default_terminate_handler()
+    {
+        __fastfail(RANGE_CHECKS_FAILURE);
+    }
+
+    inline gsl::details::terminate_handler& get_terminate_handler() noexcept
+    {
+        static terminate_handler handler = &default_terminate_handler;
+        return handler;
+    }
+
+#endif // defined(GSL_MSVC_USE_STL_NOEXCEPTION_WORKAROUND)
+
+    [[noreturn]] inline void terminate() noexcept
+    {
+#if defined(GSL_MSVC_USE_STL_NOEXCEPTION_WORKAROUND)
+        (*gsl::details::get_terminate_handler())();
+#else
+        std::terminate();
+#endif // defined(GSL_MSVC_USE_STL_NOEXCEPTION_WORKAROUND)
+    }
+
+} // namespace details
+} // namespace gsl
+
+#define GSL_CONTRACT_CHECK(type, cond)                                                             \
+    (GSL_LIKELY(cond) ? static_cast<void>(0) : gsl::details::terminate())
+
+#define Expects(cond) GSL_CONTRACT_CHECK("Precondition", cond)
+#define Ensures(cond) GSL_CONTRACT_CHECK("Postcondition", cond)
+
+#if defined(GSL_MSVC_USE_STL_NOEXCEPTION_WORKAROUND) && defined(__clang__)
+#pragma clang diagnostic pop
+#endif
+
+#endif // GSL_CONTRACTS_H
@@ -1,3 +1,209 @@
-#pragma once
-#pragma message("This header will soon be removed. Use <gsl/byte> instead of <gsl/gsl_byte>")
-#include <gsl/byte>
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
+//
+// This code is licensed under the MIT License (MIT).
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef GSL_BYTE_H
+#define GSL_BYTE_H
+
+//
+// make suppress attributes work for some compilers
+// Hopefully temporary until suppression standardization occurs
+//
+#if defined(__clang__)
+#define GSL_SUPPRESS(x) [[gsl::suppress("x")]]
+#else
+#if defined(_MSC_VER) && ! defined(__INTEL_COMPILER)
+#define GSL_SUPPRESS(x) [[gsl::suppress(x)]]
+#else
+#define GSL_SUPPRESS(x)
+#endif // _MSC_VER
+#endif // __clang__
+
+#include <type_traits>
+
+// VS2017 15.8 added support for the __cpp_lib_byte definition
+// To do: drop _HAS_STD_BYTE when support for pre 15.8 expires
+#ifdef _MSC_VER
+
+#pragma warning(push)
+
+// Turn MSVC /analyze rules that generate too much noise. TODO: fix in the tool.
+#pragma warning(disable : 26493) // don't use c-style casts // TODO: MSVC suppression in templates does not always work
+
+#ifndef GSL_USE_STD_BYTE
+// this tests if we are under MSVC and the standard lib has std::byte and it is enabled
+#if (defined(_HAS_STD_BYTE) && _HAS_STD_BYTE) || (defined(__cpp_lib_byte) && __cpp_lib_byte >= 201603)
+
+#define GSL_USE_STD_BYTE 1
+
+#else // (defined(_HAS_STD_BYTE) && _HAS_STD_BYTE) || (defined(__cpp_lib_byte) && __cpp_lib_byte >= 201603)
+
+#define GSL_USE_STD_BYTE 0
+
+#endif // (defined(_HAS_STD_BYTE) && _HAS_STD_BYTE) || (defined(__cpp_lib_byte) && __cpp_lib_byte >= 201603)
+#endif // GSL_USE_STD_BYTE
+
+#else // _MSC_VER
+
+#ifndef GSL_USE_STD_BYTE
+#include <cstddef> /* __cpp_lib_byte */
+// this tests if we are under GCC or Clang with enough -std=c++1z power to get us std::byte
+// also check if libc++ version is sufficient (> 5.0) or libstdc++ actually contains std::byte
+#if defined(__cplusplus) && (__cplusplus >= 201703L) && \
+  (defined(__cpp_lib_byte) && (__cpp_lib_byte >= 201603)  || \
+   defined(_LIBCPP_VERSION) && (_LIBCPP_VERSION >= 5000))
+
+#define GSL_USE_STD_BYTE 1
+
+#else // defined(__cplusplus) && (__cplusplus >= 201703L) &&
+      //   (defined(__cpp_lib_byte) && (__cpp_lib_byte >= 201603)  ||
+      //    defined(_LIBCPP_VERSION) && (_LIBCPP_VERSION >= 5000))
+
+#define GSL_USE_STD_BYTE 0
+
+#endif //defined(__cplusplus) && (__cplusplus >= 201703L) &&
+       //   (defined(__cpp_lib_byte) && (__cpp_lib_byte >= 201603)  ||
+       //    defined(_LIBCPP_VERSION) && (_LIBCPP_VERSION >= 5000))
+#endif // GSL_USE_STD_BYTE
+
+#endif // _MSC_VER
+
+// Use __may_alias__ attribute on gcc and clang
+#if defined __clang__ || (defined(__GNUC__) && __GNUC__ > 5)
+#define byte_may_alias __attribute__((__may_alias__))
+#else // defined __clang__ || defined __GNUC__
+#define byte_may_alias
+#endif // defined __clang__ || defined __GNUC__
+
+#if GSL_USE_STD_BYTE
+#include <cstddef>
+#endif
+
+namespace gsl
+{
+#if GSL_USE_STD_BYTE
+
+using std::byte;
+using std::to_integer;
+
+#else // GSL_USE_STD_BYTE
+
+// This is a simple definition for now that allows
+// use of byte within span<> to be standards-compliant
+enum class byte_may_alias byte : unsigned char
+{
+};
+
+template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
+constexpr byte& operator<<=(byte& b, IntegerType shift) noexcept
+{
+    return b = byte(static_cast<unsigned char>(b) << shift);
+}
+
+template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
+constexpr byte operator<<(byte b, IntegerType shift) noexcept
+{
+    return byte(static_cast<unsigned char>(b) << shift);
+}
+
+template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
+constexpr byte& operator>>=(byte& b, IntegerType shift) noexcept
+{
+    return b = byte(static_cast<unsigned char>(b) >> shift);
+}
+
+template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
+constexpr byte operator>>(byte b, IntegerType shift) noexcept
+{
+    return byte(static_cast<unsigned char>(b) >> shift);
+}
+
+constexpr byte& operator|=(byte& l, byte r) noexcept
+{
+    return l = byte(static_cast<unsigned char>(l) | static_cast<unsigned char>(r));
+}
+
+constexpr byte operator|(byte l, byte r) noexcept
+{
+    return byte(static_cast<unsigned char>(l) | static_cast<unsigned char>(r));
+}
+
+constexpr byte& operator&=(byte& l, byte r) noexcept
+{
+    return l = byte(static_cast<unsigned char>(l) & static_cast<unsigned char>(r));
+}
+
+constexpr byte operator&(byte l, byte r) noexcept
+{
+    return byte(static_cast<unsigned char>(l) & static_cast<unsigned char>(r));
+}
+
+constexpr byte& operator^=(byte& l, byte r) noexcept
+{
+    return l = byte(static_cast<unsigned char>(l) ^ static_cast<unsigned char>(r));
+}
+
+constexpr byte operator^(byte l, byte r) noexcept
+{
+    return byte(static_cast<unsigned char>(l) ^ static_cast<unsigned char>(r));
+}
+
+constexpr byte operator~(byte b) noexcept { return byte(~static_cast<unsigned char>(b)); }
+
+template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
+constexpr IntegerType to_integer(byte b) noexcept
+{
+    return static_cast<IntegerType>(b);
+}
+
+#endif // GSL_USE_STD_BYTE
+
+template <bool E, typename T>
+constexpr byte to_byte_impl(T t) noexcept
+{
+    static_assert(
+        E, "gsl::to_byte(t) must be provided an unsigned char, otherwise data loss may occur. "
+           "If you are calling to_byte with an integer contant use: gsl::to_byte<t>() version.");
+    return static_cast<byte>(t);
+}
+template <>
+// NOTE: need suppression since c++14 does not allow "return {t}"
+// GSL_SUPPRESS(type.4) // NO-FORMAT: attribute // TODO: suppression does not work
+constexpr byte to_byte_impl<true, unsigned char>(unsigned char t) noexcept
+{
+    return byte(t);
+}
+
+template <typename T>
+constexpr byte to_byte(T t) noexcept
+{
+    return to_byte_impl<std::is_same<T, unsigned char>::value, T>(t);
+}
+
+template <int I>
+constexpr byte to_byte() noexcept
+{
+    static_assert(I >= 0 && I <= 255,
+                  "gsl::byte only has 8 bits of storage, values must be in range 0-255");
+    return static_cast<byte>(I);
+}
+
+} // namespace gsl
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif // _MSC_VER
+
+#endif // GSL_BYTE_H
@@ -1,3 +1,52 @@
-#pragma once
-#pragma message("This header will soon be removed. Use <gsl/narrow> instead of <gsl/gsl_narrow>")
-#include <gsl/narrow>
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
+//
+// This code is licensed under the MIT License (MIT).
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef GSL_NARROW_H
+#define GSL_NARROW_H
+#include <gsl/gsl_assert> // for Expects
+#include <gsl/gsl_util> // for narrow_cast
+namespace gsl
+{
+struct narrowing_error : public std::exception
+{
+    const char* what() const noexcept override
+    {
+        return "narrowing_error";
+    }
+};
+
+// narrow() : a checked version of narrow_cast() that throws if the cast changed the value
+template <class T, class U>
+GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
+GSL_SUPPRESS(f.6) // NO-FORMAT: attribute // TODO: MSVC /analyze does not recognise noexcept(false)
+constexpr
+T narrow(U u) noexcept(false)
+{
+    constexpr const bool is_different_signedness = (std::is_signed<T>::value != std::is_signed<U>::value);
+
+    const T t = narrow_cast<T>(u);
+
+    if (static_cast<U>(t) != u
+        || (is_different_signedness
+            && ((t < T{}) != (u < U{}))))
+    {
+        throw narrowing_error{};
+    }
+
+    return t;
+}
+}
+#endif // GSL_NARROW_H
@@ -1,3 +1,129 @@
-#pragma once
-#pragma message("This header will soon be removed. Use <gsl/util> instead of <gsl/gsl_util>")
-#include <gsl/util>
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
+//
+// This code is licensed under the MIT License (MIT).
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef GSL_UTIL_H
+#define GSL_UTIL_H
+
+#include <gsl/gsl_assert> // for Expects
+
+#include <array>
+#include <cstddef>          // for ptrdiff_t, size_t
+#include <initializer_list> // for initializer_list
+#include <type_traits>      // for is_signed, integral_constant
+#include <utility>          // for exchange, forward
+
+#if defined(_MSC_VER) && !defined(__clang__)
+
+#pragma warning(push)
+#pragma warning(disable : 4127) // conditional expression is constant
+
+#endif            // _MSC_VER
+
+#if defined(__cplusplus) && (__cplusplus >= 201703L)
+#define GSL_NODISCARD [[nodiscard]]
+#else
+#define GSL_NODISCARD
+#endif // defined(__cplusplus) && (__cplusplus >= 201703L)
+
+namespace gsl
+{
+//
+// GSL.util: utilities
+//
+
+// index type for all container indexes/subscripts/sizes
+using index = std::ptrdiff_t;
+
+// final_action allows you to ensure something gets run at the end of a scope
+template <class F>
+class final_action
+{
+public:
+    static_assert(!std::is_reference<F>::value && !std::is_const<F>::value && !std::is_volatile<F>::value, "Final_action should store its callable by value");
+
+    explicit final_action(F f) noexcept : f_(std::move(f)) {}
+
+    final_action(final_action&& other) noexcept : f_(std::move(other.f_)), invoke_(std::exchange(other.invoke_, false)) {}
+
+    final_action(const final_action&) = delete;
+    final_action& operator=(const final_action&) = delete;
+    final_action& operator=(final_action&&) = delete;
+
+    GSL_SUPPRESS(f.6) // NO-FORMAT: attribute // terminate if throws
+    ~final_action() noexcept
+    {
+        if (invoke_) f_();
+    }
+
+private:
+    F f_;
+    bool invoke_{true};
+};
+
+// finally() - convenience function to generate a final_action
+template <class F>
+GSL_NODISCARD final_action<typename std::remove_cv<typename std::remove_reference<F>::type>::type> finally(F&& f) noexcept
+{
+    return final_action<typename std::remove_cv<typename std::remove_reference<F>::type>::type>(std::forward<F>(f));
+}
+
+// narrow_cast(): a searchable way to do narrowing casts of values
+template <class T, class U>
+GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
+constexpr T narrow_cast(U&& u) noexcept
+{
+    return static_cast<T>(std::forward<U>(u));
+}
+
+//
+// at() - Bounds-checked way of accessing builtin arrays, std::array, std::vector
+//
+template <class T, std::size_t N>
+GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
+GSL_SUPPRESS(bounds.2) // NO-FORMAT: attribute
+constexpr T& at(T (&arr)[N], const index i)
+{
+    Expects(i >= 0 && i < narrow_cast<index>(N));
+    return arr[narrow_cast<std::size_t>(i)];
+}
+
+template <class Cont>
+GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
+GSL_SUPPRESS(bounds.2) // NO-FORMAT: attribute
+constexpr auto at(Cont& cont, const index i) -> decltype(cont[cont.size()])
+{
+    Expects(i >= 0 && i < narrow_cast<index>(cont.size()));
+    using size_type = decltype(cont.size());
+    return cont[narrow_cast<size_type>(i)];
+}
+
+template <class T>
+GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
+constexpr T at(const std::initializer_list<T> cont, const index i)
+{
+    Expects(i >= 0 && i < narrow_cast<index>(cont.size()));
+    return *(cont.begin() + i);
+}
+
+} // namespace gsl
+
+#if defined(_MSC_VER) && !defined(__clang__)
+
+#pragma warning(pop)
+
+#endif // _MSC_VER
+
+#endif // GSL_UTIL_H
@@ -17,12 +17,12 @@
 #ifndef GSL_MULTI_SPAN_H
 #define GSL_MULTI_SPAN_H

-#include <gsl/assert> // for Expects
-#include <gsl/byte>   // for byte
-#include <gsl/util>   // for narrow_cast
+#include <gsl/gsl_assert> // for Expects
+#include <gsl/gsl_byte>   // for byte
+#include <gsl/gsl_util>   // for narrow_cast

-#include <algorithm>        // for transform, lexicographical_compare
-#include <array>            // for array
+#include <algorithm> // for transform, lexicographical_compare
+#include <array>     // for array
 #include <cstddef>          // for std::ptrdiff_t, size_t, nullptr_t
 #include <cstdint>          // for PTRDIFF_MAX
 #include <functional>       // for divides, multiplies, minus, negate, plus
@@ -95,8 +95,7 @@ namespace details
 } // namespace details

 template <std::size_t Rank>
-class [[deprecated]] multi_span_index final
-{
+class [[deprecated]] multi_span_index final {
    static_assert(Rank > 0, "Rank must be greater than 0!");

    template <std::size_t OtherRank>
@@ -111,12 +110,10 @@ public:

    constexpr multi_span_index() noexcept {}

-    constexpr multi_span_index(const value_type (&values)[Rank]) noexcept
+    constexpr multi_span_index(const value_type(&values)[Rank]) noexcept
    {
-        // clang-format off
        GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
        GSL_SUPPRESS(bounds.3) // NO-FORMAT: attribute
-        // clang-format on
        std::copy(values, values + Rank, elems);
    }

@@ -130,10 +127,8 @@ public:
    constexpr multi_span_index& operator=(const multi_span_index& rhs) noexcept = default;

    // Preconditions: component_idx < rank
-    // clang-format off
    GSL_SUPPRESS(bounds.2) // NO-FORMAT: attribute
    GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
-    // clang-format on
    constexpr reference operator[](std::size_t component_idx)
    {
        Expects(component_idx < Rank); // Component index must be less than rank
@@ -141,20 +136,16 @@ public:
    }

    // Preconditions: component_idx < rank
-    // clang-format off
    GSL_SUPPRESS(bounds.2) // NO-FORMAT: attribute
    GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
-    // clang-format on
    constexpr const_reference operator[](std::size_t component_idx) const
    {
        Expects(component_idx < Rank); // Component index must be less than rank
        return elems[component_idx];
    }

-    // clang-format off
    GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
    GSL_SUPPRESS(bounds.3) // NO-FORMAT: attribute
-    // clang-format on
    constexpr bool operator==(const multi_span_index& rhs) const
    {
        return std::equal(elems, elems + rank, rhs.elems);
@@ -187,20 +178,16 @@ public:

    constexpr multi_span_index& operator+=(const multi_span_index& rhs)
    {
-        // clang-format off
        GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
        GSL_SUPPRESS(bounds.3) // NO-FORMAT: attribute
-        // clang-format on
        std::transform(elems, elems + rank, rhs.elems, elems, std::plus<value_type>{});
        return *this;
    }

    constexpr multi_span_index& operator-=(const multi_span_index& rhs)
    {
-        // clang-format off
        GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
        GSL_SUPPRESS(bounds.3) // NO-FORMAT: attribute
-        // clang-format on
        std::transform(elems, elems + rank, rhs.elems, elems, std::minus<value_type>{});
        return *this;
    }
@@ -226,10 +213,8 @@ public:

    constexpr multi_span_index& operator*=(value_type v)
    {
-        // clang-format off
        GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
        GSL_SUPPRESS(bounds.3) // NO-FORMAT: attribute
-        // clang-format on
        std::transform(elems, elems + rank, elems,
                       [v](value_type x) { return std::multiplies<value_type>{}(x, v); });
        return *this;
@@ -237,10 +222,8 @@ public:

    constexpr multi_span_index& operator/=(value_type v)
    {
-        // clang-format off
        GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
        GSL_SUPPRESS(bounds.3) // NO-FORMAT: attribute
-        // clang-format on
        std::transform(elems, elems + rank, elems,
                       [v](value_type x) { return std::divides<value_type>{}(x, v); });
        return *this;
@@ -303,9 +286,7 @@ const std::ptrdiff_t dynamic_range = -1;
 struct [[deprecated]] generalized_mapping_tag
 {
 };
-struct [[deprecated]] contiguous_mapping_tag : generalized_mapping_tag
-{
-};
+struct[[deprecated]] contiguous_mapping_tag : generalized_mapping_tag{};

 namespace details
 {
@@ -317,8 +298,7 @@ namespace details
    };

    template <std::ptrdiff_t... Ranges>
-    struct [[deprecated]] BoundsRanges
-    {
+    struct [[deprecated]] BoundsRanges {
        using size_type = std::ptrdiff_t;
        static const size_type Depth = 0;
        static const size_type DynamicNum = 0;
@@ -357,7 +337,7 @@ namespace details
    };

    template <std::ptrdiff_t... RestRanges>
-    struct [[deprecated]] BoundsRanges<dynamic_range, RestRanges...> : BoundsRanges<RestRanges...>
+    struct[[deprecated]] BoundsRanges<dynamic_range, RestRanges...> : BoundsRanges<RestRanges...>
    {
        using Base = BoundsRanges<RestRanges...>;
        using size_type = std::ptrdiff_t;
@@ -370,10 +350,9 @@ namespace details
        size_type m_bound;

    public:
-        // clang-format off
-        GSL_SUPPRESS(f.23)      // NO-FORMAT: attribute // this pointer type is cannot be assigned nullptr - issue in not_null
-        GSL_SUPPRESS(bounds.1)  // NO-FORMAT: attribute
-        // clang-format on
+        GSL_SUPPRESS(
+            f.23) // NO-FORMAT: attribute // this pointer type is cannot be assigned nullptr - issue in not_null
+        GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
        constexpr BoundsRanges(const std::ptrdiff_t* const arr)
            : Base(arr + 1), m_bound(*arr * this->Base::totalSize())
        {
@@ -390,16 +369,14 @@ namespace details
        {}

        template <typename T, std::size_t Dim = 0>
-        constexpr void serialize(T& arr) const
+        constexpr void serialize(T & arr) const
        {
            arr[Dim] = elementNum();
            this->Base::template serialize<T, Dim + 1>(arr);
        }

        template <typename T, std::size_t Dim = 0>
-        // clang-format off
        GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
-        // clang-format on
        constexpr size_type linearize(const T& arr) const
        {
            const size_type index = this->Base::totalSize() * arr[Dim];
@@ -416,22 +393,19 @@ namespace details
            return cur < m_bound ? cur + last : -1;
        }

-        // clang-format off
-        GSL_SUPPRESS(c.128) // NO-FORMAT: attribute // no pointers to BoundsRanges should be ever used
-        // clang-format on
+        GSL_SUPPRESS(
+            c.128) // NO-FORMAT: attribute // no pointers to BoundsRanges should be ever used
        constexpr size_type totalSize() const noexcept { return m_bound; }

-        // clang-format off
-        GSL_SUPPRESS(c.128) // NO-FORMAT: attribute // no pointers to BoundsRanges should be ever used
-        // clang-format on
+        GSL_SUPPRESS(
+            c.128) // NO-FORMAT: attribute // no pointers to BoundsRanges should be ever used
        constexpr size_type elementNum() const noexcept
        {
            return totalSize() / this->Base::totalSize();
        }

-        // clang-format off
-        GSL_SUPPRESS(c.128) // NO-FORMAT: attribute // no pointers to BoundsRanges should be ever used
-        // clang-format on
+        GSL_SUPPRESS(
+            c.128) // NO-FORMAT: attribute // no pointers to BoundsRanges should be ever used
        constexpr size_type elementNum(std::size_t dim) const noexcept
        {
            if (dim > 0)
@@ -448,7 +422,7 @@ namespace details
    };

    template <std::ptrdiff_t CurRange, std::ptrdiff_t... RestRanges>
-    struct [[deprecated]] BoundsRanges<CurRange, RestRanges...> : BoundsRanges<RestRanges...>
+    struct[[deprecated]] BoundsRanges<CurRange, RestRanges...> : BoundsRanges<RestRanges...>
    {
        using Base = BoundsRanges<RestRanges...>;
        using size_type = std::ptrdiff_t;
@@ -466,14 +440,12 @@ namespace details
                               bool firstLevel = true)
            : Base(static_cast<const BoundsRanges<RestOtherRanges...>&>(other), false)
        {
-            // clang-format off
            GSL_SUPPRESS(type.4) // NO-FORMAT: attribute // TODO: false positive
-            // clang-format on
            (void) firstLevel;
        }

        template <typename T, std::size_t Dim = 0>
-        constexpr void serialize(T& arr) const
+        constexpr void serialize(T & arr) const
        {
            arr[Dim] = elementNum();
            this->Base::template serialize<T, Dim + 1>(arr);
@@ -482,13 +454,9 @@ namespace details
        template <typename T, std::size_t Dim = 0>
        constexpr size_type linearize(const T& arr) const
        {
-            // clang-format off
            GSL_SUPPRESS(bounds.4)                            // NO-FORMAT: attribute
-            // clang-format on
            Expects(arr[Dim] >= 0 && arr[Dim] < CurrentRange); // Index is out of range
-            // clang-format off
            GSL_SUPPRESS(bounds.4)                            // NO-FORMAT: attribute
-            // clang-format on
            const std::ptrdiff_t d = arr[Dim];
            return this->Base::totalSize() * d + this->Base::template linearize<T, Dim + 1>(arr);
        }
@@ -502,22 +470,19 @@ namespace details
            return this->Base::totalSize() * arr[Dim] + last;
        }

-        // clang-format off
-        GSL_SUPPRESS(c.128) // NO-FORMAT: attribute // no pointers to BoundsRanges should be ever used
-        // clang-format on
+        GSL_SUPPRESS(
+            c.128) // NO-FORMAT: attribute // no pointers to BoundsRanges should be ever used
        constexpr size_type totalSize() const noexcept
        {
            return CurrentRange * this->Base::totalSize();
        }

-        // clang-format off
-        GSL_SUPPRESS(c.128) // NO-FORMAT: attribute // no pointers to BoundsRanges should be ever used
-        // clang-format on
+        GSL_SUPPRESS(
+            c.128) // NO-FORMAT: attribute // no pointers to BoundsRanges should be ever used
        constexpr size_type elementNum() const noexcept { return CurrentRange; }

-        // clang-format off
-        GSL_SUPPRESS(c.128) // NO-FORMAT: attribute // no pointers to BoundsRanges should be ever used
-        // clang-format on
+        GSL_SUPPRESS(
+            c.128) // NO-FORMAT: attribute // no pointers to BoundsRanges should be ever used
        constexpr size_type elementNum(std::size_t dim) const noexcept
        {
            if (dim > 0)
@@ -533,17 +498,14 @@ namespace details
    };

    template <typename SourceType, typename TargetType>
-    struct [[deprecated]] BoundsRangeConvertible
+    struct[[deprecated]] BoundsRangeConvertible
        : public std::integral_constant<bool, (SourceType::TotalSize >= TargetType::TotalSize ||
                                               TargetType::TotalSize == dynamic_range ||
                                               SourceType::TotalSize == dynamic_range ||
-                                               TargetType::TotalSize == 0)>
-    {
-    };
+                                               TargetType::TotalSize == 0)>{};

    template <typename TypeChain>
-    struct [[deprecated]] TypeListIndexer
-    {
+    struct [[deprecated]] TypeListIndexer {
        const TypeChain& obj_;
        constexpr TypeListIndexer(const TypeChain& obj) : obj_(obj) {}

@@ -556,13 +518,13 @@ namespace details
        template <std::size_t N, typename MyChain = TypeChain,
                  typename MyBase = typename MyChain::Base>
        constexpr auto getObj(std::false_type)
-            -> decltype(TypeListIndexer<MyBase>(static_cast<const MyBase&>(obj_)).template get<N>())
+            ->decltype(TypeListIndexer<MyBase>(static_cast<const MyBase&>(obj_)).template get<N>())
        {
            return TypeListIndexer<MyBase>(static_cast<const MyBase&>(obj_)).template get<N>();
        }

        template <std::size_t N>
-        constexpr auto get() -> decltype(getObj<N - 1>(std::integral_constant<bool, N == 0>()))
+        constexpr auto get()->decltype(getObj<N - 1>(std::integral_constant<bool, N == 0>()))
        {
            return getObj<N - 1>(std::integral_constant<bool, N == 0>());
        }
@@ -581,9 +543,7 @@ namespace details
        Ret ret{};
        for (std::size_t i = 0; i < Rank - 1; ++i)
        {
-            // clang-format off
            GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
-            // clang-format on
            ret[i] = other[i + 1];
        }
        return ret;
@@ -594,14 +554,13 @@ template <typename IndexType>
 class [[deprecated]] bounds_iterator;

 template <std::ptrdiff_t... Ranges>
-class [[deprecated]] static_bounds
-{
+class [[deprecated]] static_bounds {
 public:
    static_bounds(const details::BoundsRanges<Ranges...>&) {}
 };

 template <std::ptrdiff_t FirstRange, std::ptrdiff_t... RestRanges>
-class [[deprecated]] static_bounds<FirstRange, RestRanges...>
+class[[deprecated]] static_bounds<FirstRange, RestRanges...>
 {
    using MyRanges = details::BoundsRanges<FirstRange, RestRanges...>;

@@ -633,10 +592,10 @@ public:
    template <std::size_t Rank, typename SourceType, typename TargetType,
              typename Ret = BoundsRangeConvertible2<typename SourceType::Base,
                                                     typename TargetType::Base, Rank>>
-    static auto helpBoundsRangeConvertible(SourceType, TargetType, std::true_type) -> Ret;
+    static auto helpBoundsRangeConvertible(SourceType, TargetType, std::true_type)->Ret;

    template <std::size_t Rank, typename SourceType, typename TargetType>
-    static auto helpBoundsRangeConvertible(SourceType, TargetType, ...) -> std::false_type;
+    static auto helpBoundsRangeConvertible(SourceType, TargetType, ...)->std::false_type;

    template <typename SourceType, typename TargetType, std::size_t Rank>
    struct BoundsRangeConvertible2
@@ -762,8 +721,7 @@ public:
 };

 template <std::size_t Rank>
-class [[deprecated]] strided_bounds
-{
+class [[deprecated]] strided_bounds {
    template <std::size_t OtherRank>
    friend class strided_bounds;

@@ -787,7 +745,7 @@ public:

    constexpr strided_bounds& operator=(const strided_bounds&) noexcept = default;

-    constexpr strided_bounds(const value_type (&values)[rank], index_type strides)
+    constexpr strided_bounds(const value_type(&values)[rank], index_type strides)
        : m_extents(values), m_strides(std::move(strides))
    {}

@@ -797,9 +755,7 @@ public:

    constexpr index_type strides() const noexcept { return m_strides; }

-    // clang-format off
    GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
-    // clang-format on
    constexpr size_type total_size() const noexcept
    {
        size_type ret = 0;
@@ -807,9 +763,7 @@ public:
        return ret + 1;
    }

-    // clang-format off
    GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
-    // clang-format on
    constexpr size_type size() const noexcept
    {
        size_type ret = 1;
@@ -826,9 +780,7 @@ public:
        return true;
    }

-    // clang-format off
    GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
-    // clang-format on
    constexpr size_type linearize(const index_type& idx) const
    {
        size_type ret = 0;
@@ -840,9 +792,7 @@ public:
        return ret;
    }

-    // clang-format off
    GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
-    // clang-format on
    constexpr size_type stride() const noexcept { return m_strides[0]; }

    template <bool Enabled = (rank > 1), typename Ret = std::enable_if_t<Enabled, sliced_type>>
@@ -853,9 +803,7 @@ public:

    template <std::size_t Dim = 0>

-    // clang-format off
    GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
-    // clang-format on
    constexpr size_type extent() const noexcept
    {
        static_assert(Dim < Rank,
@@ -875,21 +823,14 @@ private:
 };

 template <typename T>
-struct [[deprecated]] is_bounds : std::integral_constant<bool, false>
-{
-};
+struct[[deprecated]] is_bounds : std::integral_constant<bool, false>{};
 template <std::ptrdiff_t... Ranges>
-struct [[deprecated]] is_bounds<static_bounds<Ranges...>> : std::integral_constant<bool, true>
-{
-};
+struct[[deprecated]] is_bounds<static_bounds<Ranges...>> : std::integral_constant<bool, true>{};
 template <std::size_t Rank>
-struct [[deprecated]] is_bounds<strided_bounds<Rank>> : std::integral_constant<bool, true>
-{
-};
+struct[[deprecated]] is_bounds<strided_bounds<Rank>> : std::integral_constant<bool, true>{};

 template <typename IndexType>
-class [[deprecated]] bounds_iterator
-{
+class [[deprecated]] bounds_iterator {
 public:
    static const std::size_t rank = IndexType::rank;
    using iterator_category = std::random_access_iterator_tag;
@@ -910,10 +851,8 @@ public:

    constexpr pointer operator->() const noexcept { return &curr_; }

-    // clang-format off
    GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
    GSL_SUPPRESS(bounds.2) // NO-FORMAT: attribute
-    // clang-format on
    constexpr bounds_iterator& operator++() noexcept

    {
@@ -938,9 +877,7 @@ public:
        return ret;
    }

-    // clang-format off
    GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
-    // clang-format on
    constexpr bounds_iterator& operator--()
    {
        if (!less(curr_, boundary_))
@@ -977,9 +914,7 @@ public:
        return ret += n;
    }

-    // clang-format off
    GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
-    // clang-format on
    constexpr bounds_iterator& operator+=(difference_type n)
    {
        auto linear_idx = linearize(curr_) + n;
@@ -1029,17 +964,15 @@ public:

    constexpr bool operator>=(const bounds_iterator& rhs) const noexcept { return !(rhs > *this); }

-    void swap(bounds_iterator& rhs) noexcept
+    void swap(bounds_iterator & rhs) noexcept
    {
        std::swap(boundary_, rhs.boundary_);
        std::swap(curr_, rhs.curr_);
    }

 private:
-    // clang-format off
    GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
-    // clang-format on
-    constexpr bool less(index_type& one, index_type& other) const noexcept
+    constexpr bool less(index_type & one, index_type & other) const noexcept
    {
        for (std::size_t i = 0; i < rank; ++i)
        {
@@ -1048,9 +981,7 @@ private:
        return false;
    }

-    // clang-format off
    GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
-    // clang-format on
    constexpr index_size_type linearize(const value_type& idx) const noexcept
    {
        // TODO: Smarter impl.
@@ -1112,10 +1043,8 @@ namespace details
        stride[Bounds::rank - 1] = 1;
        for (std::size_t i = 1; i < Bounds::rank; ++i)
        {
-            // clang-format off
            GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
            GSL_SUPPRESS(bounds.2) // NO-FORMAT: attribute
-            // clang-format on
            stride[Bounds::rank - i - 1] = stride[Bounds::rank - i] * extents[Bounds::rank - i];
        }
        return {stride};
@@ -1169,12 +1098,10 @@ constexpr dim_t<N> dim(std::ptrdiff_t n) noexcept

 template <typename ValueType, std::ptrdiff_t FirstDimension = dynamic_range,
          std::ptrdiff_t... RestDimensions>
-class [[deprecated(
-    "gsl::multi_span is deprecated because it is not in the C++ Core Guidelines")]] multi_span;
+class [[deprecated("gsl::multi_span is deprecated because it is not in the C++ Core Guidelines")]] multi_span;

 template <typename ValueType, std::size_t Rank>
-class [[deprecated(
-    "gsl::strided_span is deprecated because it is not in the C++ Core Guidelines")]] strided_span;
+class [[deprecated("gsl::strided_span is deprecated because it is not in the C++ Core Guidelines")]] strided_span;

 namespace details
 {
@@ -1261,8 +1188,8 @@ namespace details
    };

    template <typename ValueType, std::ptrdiff_t FirstDimension, std::ptrdiff_t... RestDimensions>
-    struct [[deprecated]] is_multi_span_oracle<
-        multi_span<ValueType, FirstDimension, RestDimensions...>> : std::true_type
+    struct [[deprecated]] is_multi_span_oracle<multi_span<ValueType, FirstDimension, RestDimensions...>>
+        : std::true_type
    {
    };

@@ -1278,9 +1205,7 @@ namespace details
 } // namespace details

 template <typename ValueType, std::ptrdiff_t FirstDimension, std::ptrdiff_t... RestDimensions>
-class [[deprecated(
-    "gsl::multi_span is deprecated because it is not in the C++ Core Guidelines")]] multi_span
-{
+class [[deprecated("gsl::multi_span is deprecated because it is not in the C++ Core Guidelines")]] multi_span {
    // TODO do we still need this?
    template <typename ValueType2, std::ptrdiff_t FirstDimension2,
              std::ptrdiff_t... RestDimensions2>
@@ -1312,9 +1237,7 @@ private:

 public:
    // default constructor - same as constructing from nullptr_t
-    // clang-format off
    GSL_SUPPRESS(type.6) // NO-FORMAT: attribute // TODO: false positive
-    // clang-format on
    constexpr multi_span() noexcept : multi_span(nullptr, bounds_type{})
    {
        static_assert(bounds_type::dynamic_rank != 0 ||
@@ -1324,9 +1247,7 @@ public:
    }

    // construct from nullptr - get an empty multi_span
-    // clang-format off
    GSL_SUPPRESS(type.6) // NO-FORMAT: attribute // TODO: false positive
-    // clang-format on
    constexpr multi_span(std::nullptr_t) noexcept : multi_span(nullptr, bounds_type{})
    {
        static_assert(bounds_type::dynamic_rank != 0 ||
@@ -1350,9 +1271,7 @@ public:

    // construct from a single element

-    // clang-format off
    GSL_SUPPRESS(type.6) // NO-FORMAT: attribute // TODO: false positive
-    // clang-format on
    constexpr multi_span(reference data) noexcept : multi_span(&data, bounds_type{1})
    {
        static_assert(bounds_type::dynamic_rank > 0 || bounds_type::static_size == 0 ||
@@ -1365,9 +1284,7 @@ public:
    constexpr multi_span(value_type &&) = delete;

    // construct from pointer + length
-    // clang-format off
    GSL_SUPPRESS(type.6) // NO-FORMAT: attribute // TODO: false positive
-    // clang-format on
    constexpr multi_span(pointer ptr, size_type size) : multi_span(ptr, bounds_type{size}) {}

    // construct from pointer + length - multidimensional
@@ -1604,9 +1521,7 @@ public:
        return this->operator[](idx);
    }

-    // clang-format off
    GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
-    // clang-format on
    constexpr reference operator[](const index_type& idx) const
    {
        return data_[bounds_.linearize(idx)];
@@ -1614,9 +1529,7 @@ public:

    template <bool Enabled = (Rank > 1), typename Ret = std::enable_if_t<Enabled, sliced_type>>

-    // clang-format off
    GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
-    // clang-format on
    constexpr Ret operator[](size_type idx) const
    {
        Expects(idx >= 0 && idx < bounds_.size()); // index is out of bounds of the array
@@ -1631,9 +1544,7 @@ public:

    constexpr iterator end() const noexcept { return iterator{this, false}; }

-    // clang-format off
    GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
-    // clang-format on
    constexpr const_iterator cbegin() const noexcept
    {
        return const_iterator{reinterpret_cast<const const_span*>(this), true};
@@ -1731,7 +1642,8 @@ constexpr auto as_multi_span(SpanType s, Dimensions2... dims)

 // convert a multi_span<T> to a multi_span<const byte>
 template <typename U, std::ptrdiff_t... Dimensions>
-multi_span<const byte, dynamic_range> as_bytes(multi_span<U, Dimensions...> s) noexcept
+multi_span<const byte, dynamic_range>
+as_bytes(multi_span<U, Dimensions...> s) noexcept
 {
    static_assert(std::is_trivial<std::decay_t<U>>::value,
                  "The value_type of multi_span must be a trivial type.");
@@ -1817,7 +1729,8 @@ constexpr auto as_multi_span(T* arr, std::ptrdiff_t len) ->
 }

 template <typename T, std::size_t N>
-constexpr auto as_multi_span(T (&arr)[N]) -> typename details::SpanArrayTraits<T, N>::type
+constexpr auto as_multi_span(T (&arr)[N]) ->
+    typename details::SpanArrayTraits<T, N>::type
 {
    return {arr};
 }
@@ -1859,9 +1772,7 @@ constexpr auto as_multi_span(Cont&& arr) -> std::enable_if_t<

 // from basic_string which doesn't have nonconst .data() member like other contiguous containers
 template <typename CharT, typename Traits, typename Allocator>
-// clang-format off
 GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
-// clang-format on
 constexpr auto as_multi_span(std::basic_string<CharT, Traits, Allocator>& str)
    -> multi_span<CharT, dynamic_range>
 {
@@ -1872,8 +1783,7 @@ constexpr auto as_multi_span(std::basic_string<CharT, Traits, Allocator>& str)
 // strided_span is an extension that is not strictly part of the GSL at this time.
 // It is kept here while the multidimensional interface is still being defined.
 template <typename ValueType, std::size_t Rank>
-class [[deprecated(
-    "gsl::strided_span is deprecated because it is not in the C++ Core Guidelines")]] strided_span
+class [[deprecated("gsl::strided_span is deprecated because it is not in the C++ Core Guidelines")]] strided_span
 {
 public:
    using bounds_type = strided_bounds<Rank>;
@@ -1908,15 +1818,13 @@ public:
        Expects((bounds_.size() > 0 && ptr != nullptr) || bounds_.size() == 0);
        // Bounds cross data boundaries
        Expects(this->bounds().total_size() <= size);
-        // clang-format off
        GSL_SUPPRESS(type.4) // NO-FORMAT: attribute // TODO: false positive
-        // clang-format on
        (void) size;
    }

    // from static array of size N
    template <size_type N>
-    constexpr strided_span(value_type(&values)[N], bounds_type bounds)
+    constexpr strided_span(value_type (&values)[N], bounds_type bounds)
        : strided_span(values, N, std::move(bounds))
    {}

@@ -1931,7 +1839,7 @@ public:

    // convertible
    template <typename OtherValueType, typename = std::enable_if_t<std::is_convertible<
-                                           OtherValueType(*)[], value_type(*)[]>::value>>
+                                           OtherValueType (*)[], value_type (*)[]>::value>>
    constexpr strided_span(const strided_span<OtherValueType, Rank>& other)
        : data_(other.data_), bounds_(other.bounds_)
    {}
@@ -1950,9 +1858,7 @@ public:

        const size_type size = this->bounds().total_size() / d;

-        // clang-format off
        GSL_SUPPRESS(type.3) // NO-FORMAT: attribute
-        // clang-format on
        return {const_cast<OtherValueType*>(reinterpret_cast<const OtherValueType*>(this->data())),
                size,
                bounds_type{resize_extent(this->bounds().index_bounds(), d),
@@ -1966,18 +1872,14 @@ public:
                bounds_type{extents, details::make_stride(bounds())}};
    }

-    // clang-format off
    GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
-    // clang-format on
    constexpr reference operator[](const index_type& idx) const
    {
        return data_[bounds_.linearize(idx)];
    }

    template <bool Enabled = (Rank > 1), typename Ret = std::enable_if_t<Enabled, sliced_type>>
-    // clang-format off
    GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
-    // clang-format on
    constexpr Ret operator[](size_type idx) const
    {
        Expects(idx < bounds_.size()); // index is out of bounds of the array
@@ -2081,9 +1983,7 @@ private:
    static index_type resize_extent(const index_type& extent, std::ptrdiff_t d)
    {
        // The last dimension of the array needs to contain a multiple of new type elements
-        // clang-format off
        GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
-        // clang-format on
        Expects(extent[Rank - 1] >= d && (extent[Rank - 1] % d == 0));

        index_type ret = extent;
@@ -2096,18 +1996,14 @@ private:
    static index_type resize_stride(const index_type& strides, std::ptrdiff_t, void* = nullptr)
    {
        // Only strided arrays with regular strides can be resized
-        // clang-format off
        GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
-        // clang-format on
        Expects(strides[Rank - 1] == 1);

        return strides;
    }

    template <bool Enabled = (Rank > 1), typename = std::enable_if_t<Enabled>>
-    // clang-format off
    GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
-    // clang-format on
    static index_type resize_stride(const index_type& strides, std::ptrdiff_t d)
    {
        // Only strided arrays with regular strides can be resized
@@ -2130,8 +2026,7 @@ private:
 };

 template <class Span>
-class [[deprecated]] contiguous_span_iterator
-{
+class [[deprecated]] contiguous_span_iterator {
 public:
    using iterator_category = std::random_access_iterator_tag;
    using value_type = typename Span::value_type;
@@ -2146,18 +2041,14 @@ private:
    pointer data_;
    const Span* m_validator;

-    // clang-format off
    GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
-    // clang-format on
    void validateThis() const
    {
        // iterator is out of range of the array
        Expects(data_ >= m_validator->data_ && data_ < m_validator->data_ + m_validator->size());
    }

-    // clang-format off
    GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
-    // clang-format on
    contiguous_span_iterator(const Span* container, bool isbegin)
        : data_(isbegin ? container->data_ : container->data_ + container->size())
        , m_validator(container)
@@ -2175,9 +2066,7 @@ public:
        return data_;
    }

-    // clang-format off
    GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
-    // clang-format on
    contiguous_span_iterator& operator++() noexcept
    {
        ++data_;
@@ -2190,9 +2079,7 @@ public:
        return ret;
    }

-    // clang-format off
    GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
-    // clang-format on
    contiguous_span_iterator& operator--() noexcept
    {
        --data_;
@@ -2245,7 +2132,7 @@ public:
    bool operator>(const contiguous_span_iterator& rhs) const { return rhs < *this; }
    bool operator>=(const contiguous_span_iterator& rhs) const { return !(rhs > *this); }

-    void swap(contiguous_span_iterator& rhs) noexcept
+    void swap(contiguous_span_iterator & rhs) noexcept
    {
        std::swap(data_, rhs.data_);
        std::swap(m_validator, rhs.m_validator);
@@ -2260,8 +2147,7 @@ contiguous_span_iterator<Span> operator+(typename contiguous_span_iterator<Span>
 }

 template <typename Span>
-class [[deprecated]] general_span_iterator
-{
+class [[deprecated]] general_span_iterator {
 public:
    using iterator_category = std::random_access_iterator_tag;
    using value_type = typename Span::value_type;
@@ -2327,9 +2213,7 @@ public:
        return m_itr - rhs.m_itr;
    }

-    // clang-format off
    GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
-    // clang-format on
    value_type operator[](difference_type n) const { return (*m_container)[m_itr[n]]; }

    bool operator==(const general_span_iterator& rhs) const
@@ -2346,7 +2230,7 @@ public:
    bool operator<=(const general_span_iterator& rhs) const { return !(rhs < *this); }
    bool operator>(const general_span_iterator& rhs) const { return rhs < *this; }
    bool operator>=(const general_span_iterator& rhs) const { return !(rhs > *this); }
-    void swap(general_span_iterator& rhs) noexcept
+    void swap(general_span_iterator & rhs) noexcept
    {
        std::swap(m_itr, rhs.m_itr);
        std::swap(m_container, rhs.m_container);
@@ -1,49 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
-//
-// This code is licensed under the MIT License (MIT).
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef GSL_NARROW_H
-#define GSL_NARROW_H
-#include <gsl/assert> // for contracts
-#include <gsl/util>   // for narrow_cast
-namespace gsl
-{
-struct narrowing_error : public std::exception
-{
-    const char* what() const noexcept override { return "narrowing_error"; }
-};
-
-// narrow() : a checked version of narrow_cast() that throws if the cast changed the value
-template <class T, class U>
-// clang-format off
-GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
-GSL_SUPPRESS(f.6) // NO-FORMAT: attribute // TODO: MSVC /analyze does not recognise noexcept(false)
-// clang-format on
-    constexpr T narrow(U u) noexcept(false)
-{
-    constexpr const bool is_different_signedness =
-        (std::is_signed<T>::value != std::is_signed<U>::value);
-
-    const T t = narrow_cast<T>(u);
-
-    if (static_cast<U>(t) != u || (is_different_signedness && ((t < T{}) != (u < U{}))))
-    {
-        throw narrowing_error{};
-    }
-
-    return t;
-}
-} // namespace gsl
-#endif // GSL_NARROW_H
@@ -17,32 +17,27 @@
 #ifndef GSL_POINTERS_H
 #define GSL_POINTERS_H

-#include <gsl/assert>   // for contracts
+#include <gsl/gsl_assert>  // for Ensures, Expects

 #include <algorithm>    // for forward
-#include <cstddef>      // for ptrdiff_t, nullptr_t, size_t
+#include <iosfwd>       // for ptrdiff_t, nullptr_t, ostream, size_t
 #include <memory>       // for shared_ptr, unique_ptr
 #include <system_error> // for hash
 #include <type_traits>  // for enable_if_t, is_convertible, is_assignable

-#if !defined(GSL_NO_IOSTREAMS)
-#include <iosfwd> // for ostream
-#endif            // !defined(GSL_NO_IOSTREAMS)
-
 namespace gsl
 {

 //
 // GSL.owner: ownership pointers
 //
-using std::shared_ptr;
 using std::unique_ptr;
+using std::shared_ptr;

 //
 // owner
 //
-// owner<T> is designed as a bridge for code that must deal directly with owning pointers for some
-// reason
+// owner<T> is designed as a bridge for code that must deal directly with owning pointers for some reason
 //
 // T must be a pointer type
 // - disallow construction from any type other than pointer type
@@ -68,30 +63,30 @@ template <class T>
 class not_null
 {
 public:
-    static_assert(std::is_convertible<decltype(std::declval<T>() != nullptr), bool>::value,
-                  "T cannot be compared to nullptr.");
+    static_assert(std::is_convertible<decltype(std::declval<T>() != nullptr), bool>::value, "T cannot be compared to nullptr.");

    template <typename U, typename = std::enable_if_t<std::is_convertible<U, T>::value>>
    constexpr not_null(U&& u) : ptr_(std::forward<U>(u))
    {
-        Expects(ptr_ != nullptr, Null);
+        Expects(ptr_ != nullptr);
    }

    template <typename = std::enable_if_t<!std::is_same<std::nullptr_t, T>::value>>
    constexpr not_null(T u) : ptr_(std::move(u))
    {
-        Expects(ptr_ != nullptr, Null);
+        Expects(ptr_ != nullptr);
    }

    template <typename U, typename = std::enable_if_t<std::is_convertible<U, T>::value>>
    constexpr not_null(const not_null<U>& other) : not_null(other.get())
-    {}
+    {
+    }

    not_null(const not_null& other) = default;
    not_null& operator=(const not_null& other) = default;
    constexpr std::conditional_t<std::is_copy_constructible<T>::value, T, const T&> get() const
    {
-        Ensures(ptr_ != nullptr, Null);
+        Ensures(ptr_ != nullptr);
        return ptr_;
    }

@@ -117,64 +112,49 @@ private:
 };

 template <class T>
-auto make_not_null(T&& t) noexcept
-{
+auto make_not_null(T&& t) noexcept {
    return not_null<std::remove_cv_t<std::remove_reference_t<T>>>{std::forward<T>(t)};
 }

-#if !defined(GSL_NO_IOSTREAMS)
 template <class T>
 std::ostream& operator<<(std::ostream& os, const not_null<T>& val)
 {
    os << val.get();
    return os;
 }
-#endif // !defined(GSL_NO_IOSTREAMS)

 template <class T, class U>
-auto operator==(const not_null<T>& lhs,
-                const not_null<U>& rhs) noexcept(noexcept(lhs.get() == rhs.get()))
-    -> decltype(lhs.get() == rhs.get())
+auto operator==(const not_null<T>& lhs, const not_null<U>& rhs) noexcept(noexcept(lhs.get() == rhs.get())) -> decltype(lhs.get() == rhs.get())
 {
    return lhs.get() == rhs.get();
 }

 template <class T, class U>
-auto operator!=(const not_null<T>& lhs,
-                const not_null<U>& rhs) noexcept(noexcept(lhs.get() != rhs.get()))
-    -> decltype(lhs.get() != rhs.get())
+auto operator!=(const not_null<T>& lhs, const not_null<U>& rhs) noexcept(noexcept(lhs.get() != rhs.get())) -> decltype(lhs.get() != rhs.get())
 {
    return lhs.get() != rhs.get();
 }

 template <class T, class U>
-auto operator<(const not_null<T>& lhs,
-               const not_null<U>& rhs) noexcept(noexcept(lhs.get() < rhs.get()))
-    -> decltype(lhs.get() < rhs.get())
+auto operator<(const not_null<T>& lhs, const not_null<U>& rhs) noexcept(noexcept(lhs.get() < rhs.get())) -> decltype(lhs.get() < rhs.get())
 {
    return lhs.get() < rhs.get();
 }

 template <class T, class U>
-auto operator<=(const not_null<T>& lhs,
-                const not_null<U>& rhs) noexcept(noexcept(lhs.get() <= rhs.get()))
-    -> decltype(lhs.get() <= rhs.get())
+auto operator<=(const not_null<T>& lhs, const not_null<U>& rhs) noexcept(noexcept(lhs.get() <= rhs.get())) -> decltype(lhs.get() <= rhs.get())
 {
    return lhs.get() <= rhs.get();
 }

 template <class T, class U>
-auto operator>(const not_null<T>& lhs,
-               const not_null<U>& rhs) noexcept(noexcept(lhs.get() > rhs.get()))
-    -> decltype(lhs.get() > rhs.get())
+auto operator>(const not_null<T>& lhs, const not_null<U>& rhs) noexcept(noexcept(lhs.get() > rhs.get())) -> decltype(lhs.get() > rhs.get())
 {
    return lhs.get() > rhs.get();
 }

 template <class T, class U>
-auto operator>=(const not_null<T>& lhs,
-                const not_null<U>& rhs) noexcept(noexcept(lhs.get() >= rhs.get()))
-    -> decltype(lhs.get() >= rhs.get())
+auto operator>=(const not_null<T>& lhs, const not_null<U>& rhs) noexcept(noexcept(lhs.get() >= rhs.get())) -> decltype(lhs.get() >= rhs.get())
 {
    return lhs.get() >= rhs.get();
 }
@@ -222,23 +202,28 @@ namespace gsl
 //   - remove unnecessary asserts
 //
 template <class T>
-class strict_not_null : public not_null<T>
+class strict_not_null: public not_null<T>
 {
 public:
+
    template <typename U, typename = std::enable_if_t<std::is_convertible<U, T>::value>>
-    constexpr explicit strict_not_null(U&& u) : not_null<T>(std::forward<U>(u))
+    constexpr explicit strict_not_null(U&& u) :
+        not_null<T>(std::forward<U>(u))
    {}

    template <typename = std::enable_if_t<!std::is_same<std::nullptr_t, T>::value>>
-    constexpr explicit strict_not_null(T u) : not_null<T>(u)
+    constexpr explicit strict_not_null(T u) :
+        not_null<T>(u)
    {}

    template <typename U, typename = std::enable_if_t<std::is_convertible<U, T>::value>>
-    constexpr strict_not_null(const not_null<U>& other) : not_null<T>(other)
+    constexpr strict_not_null(const not_null<U>& other) :
+        not_null<T>(other)
    {}

    template <typename U, typename = std::enable_if_t<std::is_convertible<U, T>::value>>
-    constexpr strict_not_null(const strict_not_null<U>& other) : not_null<T>(other)
+    constexpr strict_not_null(const strict_not_null<U>& other) :
+        not_null<T>(other)
    {}

    strict_not_null(strict_not_null&& other) = default;
@@ -275,18 +260,15 @@ template <class T>
 strict_not_null<T> operator+(std::ptrdiff_t, const strict_not_null<T>&) = delete;

 template <class T>
-auto make_strict_not_null(T&& t) noexcept
-{
+auto make_strict_not_null(T&& t) noexcept {
    return strict_not_null<std::remove_cv_t<std::remove_reference_t<T>>>{std::forward<T>(t)};
 }

-#if (defined(__cpp_deduction_guides) && (__cpp_deduction_guides >= 201611L))
+#if ( defined(__cpp_deduction_guides) && (__cpp_deduction_guides >= 201611L) )

 // deduction guides to prevent the ctad-maybe-unsupported warning
-template <class T>
-not_null(T) -> not_null<T>;
-template <class T>
-strict_not_null(T) -> strict_not_null<T>;
+template <class T> not_null(T) -> not_null<T>;
+template <class T> strict_not_null(T) -> strict_not_null<T>;

 #endif // ( defined(__cpp_deduction_guides) && (__cpp_deduction_guides >= 201611L) )

@@ -297,10 +279,7 @@ namespace std
 template <class T>
 struct hash<gsl::strict_not_null<T>>
 {
-    std::size_t operator()(const gsl::strict_not_null<T>& value) const
-    {
-        return hash<T>{}(value.get());
-    }
+    std::size_t operator()(const gsl::strict_not_null<T>& value) const { return hash<T>{}(value.get()); }
 };

 } // namespace std
@@ -17,9 +17,9 @@
 #ifndef GSL_SPAN_H
 #define GSL_SPAN_H

-#include <gsl/assert> // for contracts
-#include <gsl/byte>   // for byte
-#include <gsl/util>   // for narrow_cast
+#include <gsl/gsl_assert> // for Expects
+#include <gsl/gsl_byte>   // for byte
+#include <gsl/gsl_util>   // for narrow_cast

 #include <array>       // for array
 #include <cstddef>     // for ptrdiff_t, size_t, nullptr_t
@@ -29,7 +29,7 @@
 #if defined(_MSC_VER) && !defined(__clang__)
 #pragma warning(push)

-// turn off some warnings that are noisy about our contract checks
+// turn off some warnings that are noisy about our Expects statements
 #pragma warning(disable : 4127) // conditional expression is constant
 #pragma warning(                                                                                   \
    disable : 4146) // unary minus operator applied to unsigned type, result still unsigned
@@ -137,24 +137,21 @@ namespace details

        constexpr reference operator*() const noexcept
        {
-            Expects(begin_ && end_, Bounds);
-            Expects(begin_ <= current_ && current_ < end_, Bounds);
+            Expects(begin_ && end_);
+            Expects(begin_ <= current_ && current_ < end_);
            return *current_;
        }

        constexpr pointer operator->() const noexcept
        {
-            Expects(begin_ && end_, Bounds);
-            Expects(begin_ <= current_ && current_ < end_, Bounds);
+            Expects(begin_ && end_);
+            Expects(begin_ <= current_ && current_ < end_);
            return current_;
        }
        constexpr span_iterator& operator++() noexcept
        {
-            Expects(begin_ && current_ && end_, Bounds);
-            Expects(current_ < end_, Bounds);
-            // clang-format off
-            GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
-            // clang-format on
+            Expects(begin_ && current_ && end_);
+            Expects(current_ < end_);
            ++current_;
            return *this;
        }
@@ -168,8 +165,8 @@ namespace details

        constexpr span_iterator& operator--() noexcept
        {
-            Expects(begin_ && end_, Bounds);
-            Expects(begin_ < current_, Bounds);
+            Expects(begin_ && end_);
+            Expects(begin_ < current_);
            --current_;
            return *this;
        }
@@ -183,12 +180,9 @@ namespace details

        constexpr span_iterator& operator+=(const difference_type n) noexcept
        {
-            if (n != 0) Expects(begin_ && current_ && end_, Bounds);
-            if (n > 0) Expects(end_ - current_ >= n, Bounds);
-            if (n < 0) Expects(current_ - begin_ >= -n, Bounds);
-            // clang-format off
-            GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
-            // clang-format on
+            if (n != 0) Expects(begin_ && current_ && end_);
+            if (n > 0) Expects(end_ - current_ >= n);
+            if (n < 0) Expects(current_ - begin_ >= -n);
            current_ += n;
            return *this;
        }
@@ -208,9 +202,9 @@ namespace details

        constexpr span_iterator& operator-=(const difference_type n) noexcept
        {
-            if (n != 0) Expects(begin_ && current_ && end_, Bounds);
-            if (n > 0) Expects(current_ - begin_ >= n, Bounds);
-            if (n < 0) Expects(end_ - current_ >= -n, Bounds);
+            if (n != 0) Expects(begin_ && current_ && end_);
+            if (n > 0) Expects(current_ - begin_ >= n);
+            if (n < 0) Expects(end_ - current_ >= -n);
            current_ -= n;
            return *this;
        }
@@ -227,7 +221,7 @@ namespace details
            std::enable_if_t<std::is_same<std::remove_cv_t<Type2>, value_type>::value, int> = 0>
        constexpr difference_type operator-(const span_iterator<Type2>& rhs) const noexcept
        {
-            Expects(begin_ == rhs.begin_ && end_ == rhs.end_, Bounds);
+            Expects(begin_ == rhs.begin_ && end_ == rhs.end_);
            return current_ - rhs.current_;
        }

@@ -241,7 +235,7 @@ namespace details
            std::enable_if_t<std::is_same<std::remove_cv_t<Type2>, value_type>::value, int> = 0>
        constexpr bool operator==(const span_iterator<Type2>& rhs) const noexcept
        {
-            Expects(begin_ == rhs.begin_ && end_ == rhs.end_, Bounds);
+            Expects(begin_ == rhs.begin_ && end_ == rhs.end_);
            return current_ == rhs.current_;
        }

@@ -258,7 +252,7 @@ namespace details
            std::enable_if_t<std::is_same<std::remove_cv_t<Type2>, value_type>::value, int> = 0>
        constexpr bool operator<(const span_iterator<Type2>& rhs) const noexcept
        {
-            Expects(begin_ == rhs.begin_ && end_ == rhs.end_, Bounds);
+            Expects(begin_ == rhs.begin_ && end_ == rhs.end_);
            return current_ < rhs.current_;
        }

@@ -294,14 +288,14 @@ namespace details
        { // test that [lhs, rhs) forms a valid range inside an STL algorithm
            Expects(lhs.begin_ == rhs.begin_ // range spans have to match
                    && lhs.end_ == rhs.end_ &&
-                    lhs.current_ <= rhs.current_, Bounds); // range must not be transposed
+                    lhs.current_ <= rhs.current_); // range must not be transposed
        }

        constexpr void _Verify_offset(const difference_type n) const noexcept
        { // test that *this + n is within the range of this call
-            if (n != 0) Expects(begin_ && current_ && end_, Bounds);
-            if (n > 0) Expects(end_ - current_ >= n, Bounds);
-            if (n < 0) Expects(current_ - begin_ >= -n, Bounds);
+            if (n != 0) Expects(begin_ && current_ && end_);
+            if (n > 0) Expects(end_ - current_ >= n);
+            if (n < 0) Expects(current_ - begin_ >= -n);
        }

        // clang-format off
@@ -346,7 +340,7 @@ namespace details

        constexpr explicit extent_type(extent_type<dynamic_extent>);

-        constexpr explicit extent_type(size_type size) { Expects(size == Ext, Bounds); }
+        constexpr explicit extent_type(size_type size) { Expects(size == Ext); }

        constexpr size_type size() const noexcept { return Ext; }

@@ -370,7 +364,7 @@ namespace details

        constexpr explicit extent_type(size_type size) : size_(size)
        {
-            Expects(size != dynamic_extent, Bounds);
+            Expects(size != dynamic_extent);
        }

        constexpr size_type size() const noexcept { return size_; }
@@ -382,7 +376,7 @@ namespace details
    template <std::size_t Ext>
    constexpr extent_type<Ext>::extent_type(extent_type<dynamic_extent> ext)
    {
-        Expects(ext.size() == Ext, Bounds);
+        Expects(ext.size() == Ext);
    }

    template <class ElementType, std::size_t Extent, std::size_t Offset, std::size_t Count>
@@ -431,7 +425,7 @@ public:
    template <std::size_t MyExtent = Extent, std::enable_if_t<MyExtent != dynamic_extent, int> = 0>
    constexpr explicit span(pointer ptr, size_type count) noexcept : storage_(ptr, count)
    {
-        Expects(count == Extent, Bounds);
+        Expects(count == Extent);
    }

    template <std::size_t MyExtent = Extent, std::enable_if_t<MyExtent == dynamic_extent, int> = 0>
@@ -442,7 +436,7 @@ public:
    constexpr explicit span(pointer firstElem, pointer lastElem) noexcept
        : storage_(firstElem, narrow_cast<std::size_t>(lastElem - firstElem))
    {
-        Expects(lastElem - firstElem == static_cast<difference_type>(Extent), Bounds);
+        Expects(lastElem - firstElem == static_cast<difference_type>(Extent));
    }

    template <std::size_t MyExtent = Extent, std::enable_if_t<MyExtent == dynamic_extent, int> = 0>
@@ -453,7 +447,7 @@ public:
    template <std::size_t N,
              std::enable_if_t<details::is_allowed_extent_conversion<N, Extent>::value, int> = 0>
    constexpr span(element_type (&arr)[N]) noexcept
-        : storage_(KnownNotNull{arr}, details::extent_type<N>())
+        : storage_(KnownNotNull{arr + 0}, details::extent_type<N>())
    {}

    template <
@@ -478,70 +472,66 @@ public:
    // requirement on Container to be a contiguous sequence container.
    template <std::size_t MyExtent = Extent, class Container,
              std::enable_if_t<
-                  MyExtent != dynamic_extent && !details::is_span<Container>::value &&
-                      !details::is_std_array<Container>::value &&
-                      std::is_pointer<decltype(std::declval<Container&>().data())>::value &&
-                      std::is_convertible<
-                          std::remove_pointer_t<decltype(std::declval<Container&>().data())> (*)[],
-                          element_type (*)[]>::value,
-                  int> = 0>
+                  MyExtent != dynamic_extent &&
+                  !details::is_span<Container>::value && !details::is_std_array<Container>::value &&
+                  std::is_pointer<decltype(std::declval<Container&>().data())>::value &&
+                  std::is_convertible<
+                      std::remove_pointer_t<decltype(std::declval<Container&>().data())> (*)[],
+                      element_type (*)[]>::value, int> = 0>
    constexpr explicit span(Container& cont) noexcept : span(cont.data(), cont.size())
    {}

    template <std::size_t MyExtent = Extent, class Container,
              std::enable_if_t<
-                  MyExtent == dynamic_extent && !details::is_span<Container>::value &&
-                      !details::is_std_array<Container>::value &&
-                      std::is_pointer<decltype(std::declval<Container&>().data())>::value &&
-                      std::is_convertible<
-                          std::remove_pointer_t<decltype(std::declval<Container&>().data())> (*)[],
-                          element_type (*)[]>::value,
-                  int> = 0>
+                  MyExtent == dynamic_extent &&
+                  !details::is_span<Container>::value && !details::is_std_array<Container>::value &&
+                  std::is_pointer<decltype(std::declval<Container&>().data())>::value &&
+                  std::is_convertible<
+                      std::remove_pointer_t<decltype(std::declval<Container&>().data())> (*)[],
+                      element_type (*)[]>::value, int> = 0>
    constexpr span(Container& cont) noexcept : span(cont.data(), cont.size())
    {}

-    template <
-        std::size_t MyExtent = Extent, class Container,
-        std::enable_if_t<
-            MyExtent != dynamic_extent && std::is_const<element_type>::value &&
-                !details::is_span<Container>::value && !details::is_std_array<Container>::value &&
-                std::is_pointer<decltype(std::declval<const Container&>().data())>::value &&
-                std::is_convertible<
-                    std::remove_pointer_t<decltype(std::declval<const Container&>().data())> (*)[],
-                    element_type (*)[]>::value,
-            int> = 0>
+    template <std::size_t MyExtent = Extent, class Container,
+              std::enable_if_t<
+                  MyExtent != dynamic_extent &&
+                  std::is_const<element_type>::value && !details::is_span<Container>::value &&
+                  !details::is_std_array<Container>::value &&
+                  std::is_pointer<decltype(std::declval<const Container&>().data())>::value &&
+                  std::is_convertible<std::remove_pointer_t<
+                      decltype(std::declval<const Container&>().data())> (*)[],
+                      element_type (*)[]>::value, int> = 0>
    constexpr explicit span(const Container& cont) noexcept : span(cont.data(), cont.size())
    {}

-    template <
-        std::size_t MyExtent = Extent, class Container,
-        std::enable_if_t<
-            MyExtent == dynamic_extent && std::is_const<element_type>::value &&
-                !details::is_span<Container>::value && !details::is_std_array<Container>::value &&
-                std::is_pointer<decltype(std::declval<const Container&>().data())>::value &&
-                std::is_convertible<
-                    std::remove_pointer_t<decltype(std::declval<const Container&>().data())> (*)[],
-                    element_type (*)[]>::value,
-            int> = 0>
+    template <std::size_t MyExtent = Extent, class Container,
+              std::enable_if_t<
+                  MyExtent == dynamic_extent &&
+                  std::is_const<element_type>::value && !details::is_span<Container>::value &&
+                  !details::is_std_array<Container>::value &&
+                  std::is_pointer<decltype(std::declval<const Container&>().data())>::value &&
+                  std::is_convertible<std::remove_pointer_t<
+                      decltype(std::declval<const Container&>().data())> (*)[],
+                      element_type (*)[]>::value, int> = 0>
    constexpr span(const Container& cont) noexcept : span(cont.data(), cont.size())
    {}

    constexpr span(const span& other) noexcept = default;

-    template <class OtherElementType, std::size_t OtherExtent, std::size_t MyExtent = Extent,
-              std::enable_if_t<(MyExtent == dynamic_extent || MyExtent == OtherExtent) &&
-                                   details::is_allowed_element_type_conversion<OtherElementType,
-                                                                               element_type>::value,
-                               int> = 0>
+    template <
+        class OtherElementType, std::size_t OtherExtent, std::size_t MyExtent = Extent,
+        std::enable_if_t<
+            (MyExtent == dynamic_extent || MyExtent == OtherExtent) &&
+            details::is_allowed_element_type_conversion<OtherElementType, element_type>::value, int> = 0>
    constexpr span(const span<OtherElementType, OtherExtent>& other) noexcept
        : storage_(other.data(), details::extent_type<OtherExtent>(other.size()))
    {}

-    template <class OtherElementType, std::size_t OtherExtent, std::size_t MyExtent = Extent,
-              std::enable_if_t<MyExtent != dynamic_extent && OtherExtent == dynamic_extent &&
-                                   details::is_allowed_element_type_conversion<OtherElementType,
-                                                                               element_type>::value,
-                               int> = 0>
+    template <
+        class OtherElementType, std::size_t OtherExtent, std::size_t MyExtent = Extent,
+        std::enable_if_t<
+            MyExtent != dynamic_extent && OtherExtent == dynamic_extent &&
+            details::is_allowed_element_type_conversion<OtherElementType, element_type>::value, int> = 0>
    constexpr explicit span(const span<OtherElementType, OtherExtent>& other) noexcept
        : storage_(other.data(), details::extent_type<OtherExtent>(other.size()))
    {}
@@ -553,7 +543,7 @@ public:
    template <std::size_t Count>
    constexpr span<element_type, Count> first() const noexcept
    {
-        Expects(Count <= size(), Bounds);
+        Expects(Count <= size());
        return span<element_type, Count>{data(), Count};
    }

@@ -563,7 +553,7 @@ public:
        // clang-format on
        constexpr span<element_type, Count> last() const noexcept
    {
-        Expects(Count <= size(), Bounds);
+        Expects(Count <= size());
        return span<element_type, Count>{data() + (size() - Count), Count};
    }

@@ -574,26 +564,26 @@ public:
        constexpr auto subspan() const noexcept ->
        typename details::calculate_subspan_type<ElementType, Extent, Offset, Count>::type
    {
-        Expects((size() >= Offset) && (Count == dynamic_extent || (Count <= size() - Offset)), Bounds);
-        using type =
-            typename details::calculate_subspan_type<ElementType, Extent, Offset, Count>::type;
+        Expects((size() >= Offset) && (Count == dynamic_extent || (Count <= size() - Offset)));
+        using type = typename details::calculate_subspan_type<ElementType, Extent, Offset, Count>::type;
        return type{data() + Offset, Count == dynamic_extent ? size() - Offset : Count};
    }

    constexpr span<element_type, dynamic_extent> first(size_type count) const noexcept
    {
-        Expects(count <= size(), Bounds);
+        Expects(count <= size());
        return {data(), count};
    }

    constexpr span<element_type, dynamic_extent> last(size_type count) const noexcept
    {
-        Expects(count <= size(), Bounds);
+        Expects(count <= size());
        return make_subspan(size() - count, dynamic_extent, subspan_selector<Extent>{});
    }

-    constexpr span<element_type, dynamic_extent>
-    subspan(size_type offset, size_type count = dynamic_extent) const noexcept
+    constexpr span<element_type, dynamic_extent> subspan(size_type offset,
+                                                         size_type count = dynamic_extent) const
+        noexcept
    {
        return make_subspan(offset, count, subspan_selector<Extent>{});
    }
@@ -603,7 +593,7 @@ public:

    constexpr size_type size_bytes() const noexcept
    {
-        Expects(size() < dynamic_extent / sizeof(element_type), Bounds);
+        Expects(size() < dynamic_extent / sizeof(element_type));
        return size() * sizeof(element_type);
    }

@@ -615,19 +605,19 @@ public:
    // clang-format on
    constexpr reference operator[](size_type idx) const noexcept
    {
-        Expects(idx < size(), Bounds);
+        Expects(idx < size());
        return data()[idx];
    }

    constexpr reference front() const noexcept
    {
-        Expects(size() > 0, Bounds);
+        Expects(size() > 0);
        return data()[0];
    }

    constexpr reference back() const noexcept
    {
-        Expects(size() > 0, Bounds);
+        Expects(size() > 0);
        return data()[size() - 1];
    }

@@ -688,14 +678,14 @@ private:
        constexpr storage_type(KnownNotNull data, OtherExtentType ext)
            : ExtentType(ext), data_(data.p)
        {
-            Expects(ExtentType::size() != dynamic_extent, Bounds);
+            Expects(ExtentType::size() != dynamic_extent);
        }

        template <class OtherExtentType>
        constexpr storage_type(pointer data, OtherExtentType ext) : ExtentType(ext), data_(data)
        {
-            Expects(ExtentType::size() != dynamic_extent, Bounds);
-            Expects(data || ExtentType::size() == 0, Bounds);
+            Expects(ExtentType::size() != dynamic_extent);
+            Expects(data || ExtentType::size() == 0);
        }

        constexpr pointer data() const noexcept { return data_; }
@@ -716,8 +706,9 @@ private:
    };

    template <std::size_t CallerExtent>
-    constexpr span<element_type, dynamic_extent>
-    make_subspan(size_type offset, size_type count, subspan_selector<CallerExtent>) const noexcept
+    constexpr span<element_type, dynamic_extent> make_subspan(size_type offset, size_type count,
+                                                              subspan_selector<CallerExtent>) const
+        noexcept
    {
        const span<element_type, dynamic_extent> tmp(*this);
        return tmp.subspan(offset, count);
@@ -729,11 +720,11 @@ private:
    constexpr span<element_type, dynamic_extent>
    make_subspan(size_type offset, size_type count, subspan_selector<dynamic_extent>) const noexcept
    {
-        Expects(size() >= offset, Bounds);
+        Expects(size() >= offset);

        if (count == dynamic_extent) { return {KnownNotNull{data() + offset}, size() - offset}; }

-        Expects(size() - offset >= count, Bounds);
+        Expects(size() - offset >= count);
        return {KnownNotNull{data() + offset}, count};
    }
 };
@@ -742,21 +733,21 @@ private:

 // Deduction Guides
 template <class Type, std::size_t Extent>
-span(Type (&)[Extent]) -> span<Type, Extent>;
+span(Type (&)[Extent])->span<Type, Extent>;

 template <class Type, std::size_t Size>
-span(std::array<Type, Size>&) -> span<Type, Size>;
+span(std::array<Type, Size>&)->span<Type, Size>;

 template <class Type, std::size_t Size>
-span(const std::array<Type, Size>&) -> span<const Type, Size>;
+span(const std::array<Type, Size>&)->span<const Type, Size>;

 template <class Container,
-          class Element = std::remove_pointer_t<decltype(std::declval<Container&>().data())>>
-span(Container&) -> span<Element>;
+    class Element = std::remove_pointer_t<decltype(std::declval<Container&>().data())>>
+span(Container&)->span<Element>;

 template <class Container,
-          class Element = std::remove_pointer_t<decltype(std::declval<const Container&>().data())>>
-span(const Container&) -> span<Element>;
+    class Element = std::remove_pointer_t<decltype(std::declval<const Container&>().data())>>
+span(const Container&)->span<Element>;

 #endif // ( defined(__cpp_deduction_guides) && (__cpp_deduction_guides >= 201611L) )

@@ -27,8 +27,9 @@
 //
 ///////////////////////////////////////////////////////////////////////////////

-#include <gsl/span> // for span
-#include <gsl/util> // for narrow_cast, narrow
+
+#include <gsl/gsl_util> // for narrow_cast, narrow
+#include <gsl/span>     // for span

 #include <algorithm> // for lexicographical_compare
 #include <cstddef>   // for ptrdiff_t, size_t
@@ -124,7 +125,7 @@ template <class ElementType, std::size_t Extent>
 constexpr ElementType& at(span<ElementType, Extent> s, index i)
 {
    // No bounds checking here because it is done in span::operator[] called below
-    Ensures(i >= 0, Bounds);
+    Ensures(i >= 0);
    return s[narrow_cast<std::size_t>(i)];
 }

@@ -17,9 +17,9 @@
 #ifndef GSL_STRING_SPAN_H
 #define GSL_STRING_SPAN_H

-#include <gsl/assert>   // for contracts
-#include <gsl/span_ext> // for operator!=, operator==, dynamic_extent
-#include <gsl/util>     // for narrow_cast
+#include <gsl/gsl_assert> // for Ensures, Expects
+#include <gsl/gsl_util>   // for narrow_cast
+#include <gsl/span_ext>   // for operator!=, operator==, dynamic_extent

 #include <algorithm> // for equal, lexicographical_compare
 #include <array>     // for array
@@ -57,31 +57,48 @@ namespace gsl
 //

 template <typename CharT, std::size_t Extent = dynamic_extent>
-using basic_zstring = CharT*;
+using basic_zstring [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                                 "information, see isocpp/CppCoreGuidelines PR#1680")]] = CharT*;

 template <std::size_t Extent = dynamic_extent>
-using czstring = basic_zstring<const char, Extent>;
+using czstring [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                            "information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_zstring<const char, Extent>;

 template <std::size_t Extent = dynamic_extent>
-using cwzstring = basic_zstring<const wchar_t, Extent>;
+using cwzstring [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                             "information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_zstring<const wchar_t, Extent>;

 template <std::size_t Extent = dynamic_extent>
-using cu16zstring = basic_zstring<const char16_t, Extent>;
+using cu16zstring [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                               "information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_zstring<const char16_t, Extent>;

 template <std::size_t Extent = dynamic_extent>
-using cu32zstring = basic_zstring<const char32_t, Extent>;
+using cu32zstring [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                               "information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_zstring<const char32_t, Extent>;

 template <std::size_t Extent = dynamic_extent>
-using zstring = basic_zstring<char, Extent>;
+using zstring [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                           "information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_zstring<char, Extent>;

 template <std::size_t Extent = dynamic_extent>
-using wzstring = basic_zstring<wchar_t, Extent>;
+using wzstring [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                            "information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_zstring<wchar_t, Extent>;

 template <std::size_t Extent = dynamic_extent>
-using u16zstring = basic_zstring<char16_t, Extent>;
+using u16zstring [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                              "information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_zstring<char16_t, Extent>;

 template <std::size_t Extent = dynamic_extent>
-using u32zstring = basic_zstring<char32_t, Extent>;
+using u32zstring [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                              "information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_zstring<char32_t, Extent>;

 namespace details
 {
@@ -114,19 +131,19 @@ template <typename T, const T Sentinel>
             "isocpp/CppCoreGuidelines PR#1680")]] constexpr span<T, dynamic_extent>
 ensure_sentinel(T* seq, std::size_t max = static_cast<std::size_t>(-1))
 {
-    Ensures(seq != nullptr, Null);
+    Ensures(seq != nullptr);

    // clang-format off
    GSL_SUPPRESS(f.23) // TODO: false positive // TODO: suppress does not work
    // clang-format on
    auto cur = seq;
-    Ensures(cur != nullptr, Null); // workaround for removing the warning
+    Ensures(cur != nullptr); // workaround for removing the warning

    // clang-format off
    GSL_SUPPRESS(bounds.1) // TODO: suppress does not work
    // clang-format on
    while (static_cast<std::size_t>(cur - seq) < max && *cur != Sentinel) ++cur;
-    Ensures(*cur == Sentinel, Bounds);
+    Ensures(*cur == Sentinel);
    return {seq, static_cast<std::size_t>(cur - seq)};
 }

@@ -167,9 +184,10 @@ class [[deprecated("string_span was removed from the C++ Core Guidelines. For mo
 namespace details
 {
    template <typename T>
-    struct [[deprecated(
-        "string_span was removed from the C++ Core Guidelines. For more information, "
-        "see isocpp/CppCoreGuidelines PR#1680")]] is_basic_string_span_oracle : std::false_type{};
+    struct [
+        [deprecated("string_span was removed from the C++ Core Guidelines. For more information, "
+                    "see isocpp/CppCoreGuidelines PR#1680")]] is_basic_string_span_oracle
+        : std::false_type{};

    template <typename CharT, std::size_t Extent>
    struct [[deprecated(
@@ -437,8 +455,8 @@ public:
    constexpr basic_zstring_span(impl_type s) : span_(s)
    {
        // expects a zero-terminated span
-        Expects(s.size() > 0, Bounds);
-        Expects(s[s.size() - 1] == value_type{}, Bounds);
+        Expects(s.size() > 0);
+        Expects(s[s.size() - 1] == value_type{});
    }

    // copy
@@ -1,145 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
-//
-// This code is licensed under the MIT License (MIT).
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef GSL_UTIL_H
-#define GSL_UTIL_H
-
-#include <gsl/assert>       // for contracts
-
-#include <array>
-#include <cstddef>          // for ptrdiff_t, size_t
-#include <initializer_list> // for initializer_list
-#include <type_traits>      // for is_signed, integral_constant
-#include <utility>          // for exchange, forward
-
-#if defined(_MSC_VER) && !defined(__clang__)
-
-#pragma warning(push)
-#pragma warning(disable : 4127) // conditional expression is constant
-
-#endif // _MSC_VER
-
-#if defined(__cplusplus) && (__cplusplus >= 201703L)
-#define GSL_NODISCARD [[nodiscard]]
-#else
-#define GSL_NODISCARD
-#endif // defined(__cplusplus) && (__cplusplus >= 201703L)
-
-namespace gsl
-{
-//
-// GSL.util: utilities
-//
-
-// index type for all container indexes/subscripts/sizes
-using index = std::ptrdiff_t;
-
-// final_action allows you to ensure something gets run at the end of a scope
-template <class F>
-class final_action
-{
-public:
-    static_assert(!std::is_reference<F>::value && !std::is_const<F>::value &&
-                      !std::is_volatile<F>::value,
-                  "Final_action should store its callable by value");
-
-    explicit final_action(F f) noexcept : f_(std::move(f)) {}
-
-    final_action(final_action&& other) noexcept
-        : f_(std::move(other.f_)), invoke_(std::exchange(other.invoke_, false))
-    {}
-
-    final_action(const final_action&) = delete;
-    final_action& operator=(const final_action&) = delete;
-    final_action& operator=(final_action&&) = delete;
-
-    // clang-format off
-    GSL_SUPPRESS(f.6) // NO-FORMAT: attribute // terminate if throws
-    // clang-format on
-    ~final_action() noexcept
-    {
-        if (invoke_) f_();
-    }
-
-private:
-    F f_;
-    bool invoke_{true};
-};
-
-// finally() - convenience function to generate a final_action
-template <class F>
-GSL_NODISCARD final_action<typename std::remove_cv<typename std::remove_reference<F>::type>::type>
-finally(F&& f) noexcept
-{
-    return final_action<typename std::remove_cv<typename std::remove_reference<F>::type>::type>(
-        std::forward<F>(f));
-}
-
-// narrow_cast(): a searchable way to do narrowing casts of values
-template <class T, class U>
-// clang-format off
-GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
-// clang-format on
-constexpr T narrow_cast(U&& u) noexcept
-{
-    return static_cast<T>(std::forward<U>(u));
-}
-
-//
-// at() - Bounds-checked way of accessing builtin arrays, std::array, std::vector
-//
-template <class T, std::size_t N>
-// clang-format off
-GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
-GSL_SUPPRESS(bounds.2) // NO-FORMAT: attribute
-// clang-format on
-    constexpr T& at(T (&arr)[N], const index i)
-{
-    Expects(i >= 0 && i < narrow_cast<index>(N), Bounds);
-    return arr[narrow_cast<std::size_t>(i)];
-}
-
-template <class Cont>
-// clang-format off
-GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
-GSL_SUPPRESS(bounds.2) // NO-FORMAT: attribute
-// clang-format on
-    constexpr auto at(Cont& cont, const index i) -> decltype(cont[cont.size()])
-{
-    Expects(i >= 0 && i < narrow_cast<index>(cont.size()), Bounds);
-    using size_type = decltype(cont.size());
-    return cont[narrow_cast<size_type>(i)];
-}
-
-template <class T>
-// clang-format off
-GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
-// clang-format on
-constexpr T at(const std::initializer_list<T> cont, const index i)
-{
-    Expects(i >= 0 && i < narrow_cast<index>(cont.size()), Bounds);
-    return *(cont.begin() + i);
-}
-
-} // namespace gsl
-
-#if defined(_MSC_VER) && !defined(__clang__)
-
-#pragma warning(pop)
-
-#endif // _MSC_VER
-
-#endif // GSL_UTIL_H
@@ -0,0 +1,11 @@
+{
+    "name": "GSL",
+    "version": "1.0.0",
+    "build": {
+        "includeDir": "include",
+        "srcFilter":
+        [
+            ".<*>"
+        ]
+    }
+}
@@ -1,26 +0,0 @@
-parameters:
-  jobName: ''
-  imageName: ''
-
-jobs:
- job:
-  displayName: ${{ parameters.imageName }}
-  pool:
-    vmImage: ${{ parameters.imageName }}
-  strategy:
-    matrix:
-      14_debug:
-        GSL_CXX_STANDARD: '14'
-        BUILD_TYPE: 'Debug'
-      14_release:
-        GSL_CXX_STANDARD: '14'
-        BUILD_TYPE: 'Release'
-      17_debug:
-        GSL_CXX_STANDARD: '17'
-        BUILD_TYPE: 'Debug'
-      17_release:
-        GSL_CXX_STANDARD: '17'
-        BUILD_TYPE: 'Release'
-  continueOnError: false
-  steps:
-  - template: ./steps.yml
@@ -1,17 +0,0 @@
-steps:
-  - task: CMake@1
-    name: Configure
-    inputs:
-      workingDirectory: build
-      cmakeArgs: '-DCMAKE_CXX_STANDARD=$(GSL_CXX_STANDARD) -DCMAKE_BUILD_TYPE=$(BUILD_TYPE) .. '
-
-  - task: CMake@1
-    name: Build
-    inputs:
-      workingDirectory: build
-      cmakeArgs: '--build . '
-
-  - script: ctest . --output-on-failure --no-compress-output
-    name: CTest
-    workingDirectory: build
-    failOnStderr: true
@@ -78,7 +78,6 @@ if(MSVC) # MSVC or simulating MSVC
          -Wno-shift-sign-overflow # GTest gtest-port.h
          -Wno-undef # GTest
          -Wno-used-but-marked-unused # GTest EXPECT_DEATH
-          -Wno-global-constructors
          $<$<EQUAL:${GSL_CXX_STANDARD},14>: # no support for [[maybe_unused]]
            -Wno-unused-member-function
            -Wno-unused-variable
@@ -110,7 +109,6 @@ else()
          -Wno-unknown-attributes
          -Wno-used-but-marked-unused # GTest EXPECT_DEATH
          -Wno-weak-vtables
-          -Wno-global-constructors
          $<$<EQUAL:${GSL_CXX_STANDARD},14>: # no support for [[maybe_unused]]
            -Wno-unused-member-function
            -Wno-unused-variable
@@ -132,8 +130,7 @@ else()
          $<$<NOT:$<VERSION_LESS:$<CXX_COMPILER_VERSION>,6>>:
            -Wduplicated-cond # duplicated if-else conditions
            -Wmisleading-indentation
-            -Wno-null-dereference
-            -Wno-array-bounds
+            -Wnull-dereference
            $<$<EQUAL:${GSL_CXX_STANDARD},14>: # no support for [[maybe_unused]]
              -Wno-unused-variable
            >
@@ -215,7 +212,6 @@ if(MSVC) # MSVC or simulating MSVC
          -Wno-c++98-compat-pedantic
          -Wno-missing-prototypes
          -Wno-unknown-attributes
-          -Wno-global-constructors
        >
    )
 else()
@@ -238,7 +234,6 @@ else()
          -Wno-missing-prototypes
          -Wno-unknown-attributes
          -Wno-weak-vtables
-          -Wno-global-constructors
        >
        $<$<CXX_COMPILER_ID:GNU>:
          -Wdouble-promotion # float implicit to double
@@ -247,8 +242,7 @@ else()
          $<$<NOT:$<VERSION_LESS:$<CXX_COMPILER_VERSION>,6>>:
            -Wduplicated-cond # duplicated if-else conditions
            -Wmisleading-indentation
-            -Wno-null-dereference
-            -Wno-array-bounds
+            -Wnull-dereference
          >
          $<$<NOT:$<VERSION_LESS:$<CXX_COMPILER_VERSION>,7>>:
            -Wduplicated-branches # identical if-else branches
@@ -15,7 +15,7 @@
 ///////////////////////////////////////////////////////////////////////////////

 #include <gtest/gtest.h>
-#include <gsl/algorithm> // for copy
+#include <gsl/gsl_algorithm> // for copy
 #include <gsl/span>          // for span
 #include <array>   // for array
 #include <cstddef> // for size_t
@@ -15,7 +15,7 @@
 ///////////////////////////////////////////////////////////////////////////////

 #include <gtest/gtest.h>
-#include <gsl/assert> // for fail_fast (ptr only), contracts
+#include <gsl/gsl_assert> // for fail_fast (ptr only), Ensures, Expects

 using namespace gsl;

@@ -25,14 +25,14 @@ static constexpr char deathstring[] = "Expected Death";

 int f(int i)
 {
-    Expects(i > 0 && i < 10, Testing);
+    Expects(i > 0 && i < 10);
    return i;
 }

 int g(int i)
 {
    i++;
-    Ensures(i > 0 && i < 10, Testing);
+    Ensures(i > 0 && i < 10);
    return i;
 }
 } // namespace
@@ -16,7 +16,7 @@

 #include <gtest/gtest.h>

-#include <gsl/util> // for at
+#include <gsl/gsl_util> // for at

 #include <array>            // for array
 #include <cstddef>          // for size_t
@@ -16,7 +16,7 @@

 #include <gtest/gtest.h>

-#include <gsl/byte> // for to_byte, to_integer, byte, operator&, ope...
+#include <gsl/gsl_byte> // for to_byte, to_integer, byte, operator&, ope...

 using namespace std;
 using namespace gsl;
@@ -16,8 +16,8 @@

 #include <gtest/gtest.h>

-#include <gsl/byte>   // for byte
-#include <gsl/util>   // for narrow_cast
+#include <gsl/gsl_byte>   // for byte
+#include <gsl/gsl_util>   // for narrow_cast
 #include <gsl/multi_span> // for multi_span, contiguous_span_iterator, dim

 #include <algorithm> // for fill, for_each
@@ -533,18 +533,3 @@ TEST(notnull_tests, TestMakeNotNull)
    }
 #endif
 }
-
-TEST(notnull_tests, TestStdHash)
-{
-    int x = 42;
-    int y = 99;
-    not_null<int*> nn{&x};
-    const not_null<int*> cnn{&x};
-
-    std::hash<not_null<int*>> hash_nn;
-    std::hash<int*> hash_intptr;
-
-    EXPECT_TRUE(hash_nn(nn) == hash_intptr(&x));
-    EXPECT_FALSE(hash_nn(nn) == hash_intptr(&y));
-    EXPECT_FALSE(hash_nn(nn) == hash_intptr(nullptr));
-}
@@ -16,7 +16,7 @@

 #include <gtest/gtest.h>

-#include <gsl/byte> // for byte
+#include <gsl/gsl_byte> // for byte
 #include <gsl/span>     // for span, span_iterator, operator==, operator!=

 #include <array>       // for array
@@ -16,7 +16,7 @@

 #include <gtest/gtest.h>

-#include <gsl/util> // for narrow_cast, at
+#include <gsl/gsl_util> // for narrow_cast, at
 #include <gsl/span_ext> // for operator==, operator!=, make_span

 #include <array>       // for array
@@ -16,8 +16,8 @@

 #include <gtest/gtest.h>

-#include <gsl/byte> // for byte
-#include <gsl/util> // for narrow_cast, at
+#include <gsl/gsl_byte> // for byte
+#include <gsl/gsl_util> // for narrow_cast, at
 #include <gsl/span>     // for span, span_iterator, operator==, operator!=

 #include <array>       // for array
@@ -15,8 +15,8 @@
 ///////////////////////////////////////////////////////////////////////////////

 #include <gtest/gtest.h>
-#include <gsl/byte>   // for byte
-#include <gsl/util>   // for narrow_cast
+#include <gsl/gsl_byte>   // for byte
+#include <gsl/gsl_util>   // for narrow_cast
 #include <gsl/multi_span> // for strided_span, index, multi_span, strided_...

 #include <iostream>    // for size_t
@@ -16,7 +16,7 @@

 #include <gtest/gtest.h>

-#include <gsl/assert>  // for contracts, fail_fast (ptr only)
+#include <gsl/gsl_assert>  // for Expects, fail_fast (ptr only)
 #include <gsl/pointers>    // for owner
 #include <gsl/span>        // for span, dynamic_extent
 #include <gsl/string_span> // for basic_string_span, operator==, ensure_z
@@ -82,7 +82,7 @@ void use(basic_string_span<T, gsl::dynamic_extent>)

 czstring_span<> CreateTempName(string_span<> span)
 {
-    Expects(span.size() > 1, Testing);
+    Expects(span.size() > 1);

    std::size_t last = 0;
    if (span.size() > 4) {
@@ -99,7 +99,7 @@ czstring_span<> CreateTempName(string_span<> span)

 cwzstring_span<> CreateTempNameW(wstring_span<> span)
 {
-    Expects(span.size() > 1, Testing);
+    Expects(span.size() > 1);

    std::size_t last = 0;
    if (span.size() > 4) {
@@ -116,7 +116,7 @@ cwzstring_span<> CreateTempNameW(wstring_span<> span)

 cu16zstring_span<> CreateTempNameU16(u16string_span<> span)
 {
-    Expects(span.size() > 1, Testing);
+    Expects(span.size() > 1);

    std::size_t last = 0;
    if (span.size() > 4) {
@@ -133,7 +133,7 @@ cu16zstring_span<> CreateTempNameU16(u16string_span<> span)

 cu32zstring_span<> CreateTempNameU32(u32string_span<> span)
 {
-    Expects(span.size() > 1, Testing);
+    Expects(span.size() > 1);

    std::size_t last = 0;
    if (span.size() > 4) {
@@ -16,8 +16,8 @@

 #include <gtest/gtest.h>

-#include <gsl/util>     // finally, narrow_cast
-#include <gsl/narrow>   // for narrow, narrowing_error
+#include <gsl/gsl_util>     // finally, narrow_cast
+#include <gsl/gsl_narrow>   // for narrow, narrowing_error
 #include <algorithm>   // for move
 #include <functional>  // for reference_wrapper, _Bind_helper<>::type
 #include <limits>      // for numeric_limits