Mark dynamic_extent as inline, compiler-version-permitting

.clang-format

@@ -31,4 +31,4 @@ AlignConsecutiveAssignments: false
 AlignTrailingComments: true
 
 SpaceAfterCStyleCast: true
-WhitespaceSensitiveMacros: [GSL_SUPPRESS]
+CommentPragmas: '^ NO-FORMAT:'

.gitattributes

@@ -1 +0,0 @@
-include/gsl/* linguist-language=C++

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,29 +0,0 @@
----
-name: Bug report
-about: Create a report to help us improve
-title: ''
-labels: 'Status: Open, Type: Bug'
-assignees: ''
-
----
-
-**Describe the bug**
-A clear and concise description of what the bug is.
-
-**To Reproduce**
-```c++
-#include <gsl>
-
-// your repro here: ...
-```
-
-**Expected behavior**
-A clear and concise description of what you expected to happen.
-
-**Spec (please complete the following information):**
- - OS: [e.g. Windows]
- - Compiler: [e.g. MSVC]
- - C++ Version: [e.g. C++20]
-
-**Additional context**
-Add any other context about the problem here.

.github/copilot-instructions.md

@@ -1,84 +0,0 @@
-# GitHub Copilot Instructions for GSL (Guidelines Support Library)
-
-## Project Overview
-This repository contains the Guidelines Support Library (GSL), a Microsoft implementation of types and functions 
-suggested for use by the C++ Core Guidelines. It's a header-only C++ library with emphasis on safety, 
-correctness, and zero overhead.
-
-## Coding Standards
-
-### General
-- Follow C++ Core Guidelines wherever possible
-- Use meaningful type, function, and template parameter names
-- Keep functions small and focused with clear preconditions/postconditions
-- Include comments for complex code, but prefer self-documenting code
-- Use the Expects() and Ensures() macros for contract verification
-
-### Style Guidelines
-- Use 4 spaces for indentation (not tabs)
-- Maximum line length of 100 characters
-- Follow GSL naming conventions (lowercase with underscores)
-- Keep templates clean and readable with appropriate spacing
-- Use C++14 features since this is the minimum standard supported
-
-### Error Handling
-- Use Expects() for preconditions and Ensures() for postconditions
-- Design for fail-fast semantics (std::terminate) on contract violations
-- Template constraints should use static_assert or SFINAE
-- Don't throw exceptions from basic operations
-
-### Testing
-- Write thorough unit tests for every component using GTest
-- Test for all edge cases and error conditions
-- Ensure cross-platform compatibility in tests
-- Maintain 100% code coverage for changed code
-
-## Project-Specific Conventions
-
-### Architecture
-- All public types must be in the gsl namespace
-- Design for zero overhead abstractions when possible
-- Respect the distinction between Owners and Views
-- Maintain backward compatibility with existing GSL code
-
-### Version Control
-- Link all PRs to related issues
-- Use clear commit messages explaining what and why
-- Follow the contribution guidelines documented in CONTRIBUTING.md
-- PRs should include appropriate tests with 100% coverage for changed code
-
-### Documentation
-- Document all public APIs with clarity on preconditions and postconditions
-- Keep header comments up-to-date
-- Include examples for complex functionality in docs/headers.md
-
-## Technology Stack
-- C++14 (minimum) for core implementation
-- CMake build system (3.14+)
-- Google Test for unit testing
-- Support for multiple compilers (MSVC, GCC, Clang)
-
-## Security Considerations
-- Bounds checking is a core principle - enforce it consistently
-- Design for safety while minimizing overhead
-- Ensure undefined behavior is explicitly detected where possible
-
-## Performance Guidelines
-- Optimize for both safety and performance
-- Constexpr-enable functions wherever possible
-- Avoid hidden allocations
-- Use noexcept appropriately for move operations and other performance-critical functions
-
-## Cross-Platform Support
-- Code must work across:
-  - Windows (MSVC)
-  - Linux (GCC, Clang)
-  - macOS (AppleClang)
-  - Android and iOS where applicable
-
-## Copilot Tasks
-- You can find the CMake artifacts for C++20 in build-cxx20 and C++14 in build-cxx14.
-- Before publishing a PR, verify the following:
-  - There are no compiler warnings or errors when building the test suite.
-  - The test suite passes on all supported platforms and compilers.
-  - The test suite passes for both C++14 and C++20.

.github/workflows/android.yml

@@ -1,9 +1,4 @@
 name: CI_Android
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
-  cancel-in-progress: true
-
 on:
   push:
     branches: [ main ]
@@ -12,43 +7,39 @@ on:
 
 jobs:
   Android:
-    runs-on: macos-latest-large
+    runs-on: macos-latest
     defaults:
       run:
         working-directory: build
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v2
 
       - name: Create build directory
         run: mkdir -p build
         working-directory: .
 
-      - uses: actions/setup-java@v5
-        with:
-          java-version: 8
-          distribution: zulu
-
-      - name: Start Emulator
+      - name: Start emulator
         run: |
           echo "y" | $ANDROID_HOME/tools/bin/sdkmanager --install 'system-images;android-24;default;x86_64'
           echo "no" | $ANDROID_HOME/tools/bin/avdmanager create avd -n xamarin_android_emulator -k 'system-images;android-24;default;x86_64' --force
           $ANDROID_HOME/emulator/emulator -list-avds
-          echo "Starting emulator..."
-          nohup $ANDROID_HOME/emulator/emulator -no-audio -no-snapshot -avd xamarin_android_emulator &> /dev/null &
-          echo "Emulator starting in background"
+          echo "Starting emulator"
+          # Start emulator in background
+          nohup $ANDROID_HOME/emulator/emulator -avd xamarin_android_emulator -no-snapshot > /dev/null 2>&1 &
+          echo "Emulator starting"
 
       - name: Configure
-        run: cmake -DCMAKE_TOOLCHAIN_FILE=$ANDROID_NDK_LATEST_HOME/build/cmake/android.toolchain.cmake -DANDROID_PLATFORM=16 -DANDROID_ABI=x86_64 -DCMAKE_BUILD_TYPE=Debug ..
+        run: cmake -Werror=dev -DCMAKE_TOOLCHAIN_FILE=$ANDROID_HOME/ndk-bundle/build/cmake/android.toolchain.cmake -DANDROID_PLATFORM=16 -DANDROID_ABI=x86_64 -DCMAKE_BUILD_TYPE=Debug ..
 
       - name: Build
         run: cmake --build . --parallel
 
       - name: Wait for emulator ready
-        timeout-minutes: 2
         run: |
           $ANDROID_HOME/platform-tools/adb wait-for-device shell 'while [[ -z $(getprop sys.boot_completed | tr -d '\r') ]]; do sleep 10; done; input keyevent 82'
           $ANDROID_HOME/platform-tools/adb devices
           $ANDROID_HOME/platform-tools/adb shell getprop ro.product.cpu.abi
+          echo "Emulator started"
 
       - name: Deploy tests
         run: |

.github/workflows/clang-format.yml

@@ -1,39 +0,0 @@
-name: Code Formatting
-
-on:
-  push:
-    branches: [ main ]
-  pull_request:
-    branches: [ main ]
-
-permissions:
-  contents: read
-
-env:
-  CLANG_VERSION: "20"
-
-jobs:
-  clang-format:
-    name: Run clang-format
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-
-      # Install the exact clang-format binary
-      - name: Install clang-format
-        run: |
-          sudo apt install clang-format-${{ env.CLANG_VERSION }}
-
-      # Prints the version of clang-format being used
-      - name: Log clang-format version
-        run: clang-format-${{ env.CLANG_VERSION }} --version
-        
-      # Runs clang-format over the repository codebase
-      - name: Check format
-        run: |
-          {
-            find include/gsl -type f
-            find tests -type f \( -name '*.cpp' -o -name '*.h' \)
-          } | xargs clang-format-${{ env.CLANG_VERSION }} --dry-run --Werror

.github/workflows/cmake/action.yml

@@ -1,33 +0,0 @@
-name: Composite CMake
-inputs:
-  cmake_preset:
-    required: true
-    type: string
-  extra_cmake_build_args:
-    required: false
-    type: string
-    default: ''
-  extra_cmake_configure_args:
-    required: false
-    type: string
-    default: ''
-  extra_ctest_args:
-    required: false
-    type: string
-    default: ''
-
-runs:
-  using: composite
-  steps:
-    - name: Configure CMake
-      run: cmake --preset ${{ inputs.cmake_preset }} ${{ inputs.extra_cmake_configure_args }} -DCI_TESTING:BOOL=ON -DCMAKE_VERBOSE_MAKEFILE:BOOL=ON -Werror=dev 
-      shell: ${{ env.RUNNER_OS == 'Windows' && 'pwsh' || 'bash' }}
-
-    - name: Build (with preset)
-      run: cmake --build --preset ${{ inputs.cmake_preset }} ${{ inputs.extra_cmake_build_args }}
-      shell: ${{ env.RUNNER_OS == 'Windows' && 'pwsh' || 'bash' }}
-
-    - name: Test (with preset)
-      run: ctest --preset ${{ inputs.cmake_preset }} ${{ inputs.extra_ctest_args }} --output-on-failure --no-compress-output
-      shell: ${{ env.RUNNER_OS == 'Windows' && 'pwsh' || 'bash' }}
-

.github/workflows/cmake_find_package.yml

@@ -1,25 +0,0 @@
-name: cmake_find_package
-on:
-  push:
-    branches: [ main ]
-  pull_request:
-    branches: [ main ]
-
-jobs:
-  cmake-find-package:
-    name: Build ${{ matrix.os }}
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [ ubuntu-latest, macos-latest ]
-    steps:
-      - uses: actions/checkout@v6
-      - uses: lukka/get-cmake@latest
-        with:
-          cmakeVersion: 3.14.0
-      - name: Configure GSL
-        run: cmake -S . -B build -G "Ninja" -D GSL_TEST=OFF -D CMAKE_INSTALL_PREFIX=${GITHUB_WORKSPACE}/build/install
-      - name: Install GSL
-        run: cmake --build build --target install
-      - name: Test GSL find_package support
-        run: cmake -S tests/ -B build/tests_find_package -G "Ninja" -D CMAKE_PREFIX_PATH=${GITHUB_WORKSPACE}/build/install -D CMAKE_BUILD_TYPE=Release

.github/workflows/compilers.yml

@@ -1,106 +0,0 @@
-name: Compiler Integration Tests
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
-  cancel-in-progress: true
-
-on:
-  push:
-    branches: [ main ]
-  pull_request:
-    branches: [ main ]
-
-# These jobs are correlated with the officially supported compilers
-# and toolsets. If you change any versions, please update README.md.
-
-jobs:
-  gcc:
-    strategy:
-      matrix:
-        gcc_version: [ 12, 13, 14 ]
-        build_type: [ Debug, Release ]
-        cxx_version: [ 14, 17, 20, 23 ]
-        exclude:
-          # https://github.com/google/googletest/issues/4232
-          # Looks like GoogleTest is not interested in making version 1.14
-          # work with gcc-12.
-          - gcc_version: 12
-            cxx_version: 20
-          - gcc_version: 12
-            cxx_version: 23
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v6
-
-      - name: Run CMake (configure, build, test)
-        uses: ./.github/workflows/cmake
-        with:
-          cmake_preset: gcc-${{ matrix.cxx_version }}-${{ matrix.build_type == 'Debug' && 'debug' || 'release' }}
-          
-  clang:
-    strategy:
-      matrix:
-        clang_version: [ 16, 17, 18 ]
-        build_type: [ Debug, Release ]
-        cxx_version: [ 14, 17, 20, 23 ]
-        exclude:
-          # https://github.com/llvm/llvm-project/issues/93734
-          # Looks like clang fixed this issue in clang-18, but won't backport
-          # the fix.
-          - clang_version: 17
-            cxx_version: 23
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v6
-     
-      - name: Run CMake (configure, build, test)
-        uses: ./.github/workflows/cmake
-        with:
-          cmake_preset: clang-${{ matrix.cxx_version }}-${{ matrix.build_type == 'Debug' && 'debug' || 'release' }}
-
-  xcode:
-    strategy:
-      matrix:
-        xcode_version: [ '16.4' ]
-        build_type: [ Debug, Release ]
-        cxx_version: [ 14, 17, 20, 23 ]
-    runs-on: macos-latest
-    steps:
-      - uses: actions/checkout@v6
-
-      - name: select xcode version
-        run: sudo xcode-select -s /Applications/Xcode_${{ matrix.xcode_version }}.app
-
-      - name: Run CMake (configure, build, test)
-        uses: ./.github/workflows/cmake
-        with:
-          cmake_preset: clang-${{ matrix.cxx_version }}-${{ matrix.build_type == 'Debug' && 'debug' || 'release' }}
-          extra_cmake_configure_args: '-DCMAKE_CXX_FLAGS="-isysroot \"$(xcode-select --print-path)/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk\""'
-
-  msvc:
-    strategy:
-      matrix:
-        image: [ windows-2022, windows-2025 ]
-        build_type: [ Debug, Release ]
-        toolset: [ 'msvc', 'ClangCL' ]
-        cxx_version: [ 14, 17, 20, 23 ]
-        include:
-          # Regular MSVC builds use Ninja (from preset)
-          - toolset: 'msvc'
-            generator_override: ''
-          # ClangCL builds require Visual Studio generator
-          - toolset: 'ClangCL'
-            generator_override: '-G "Visual Studio 17 2022" -T ClangCL'
-    runs-on: ${{ matrix.image }}
-    steps:
-      - uses: actions/checkout@v6
-      - uses: microsoft/setup-msbuild@v3
-      - uses: ilammy/msvc-dev-cmd@v1
-
-      - name: Run CMake (configure, build, test)
-        uses: ./.github/workflows/cmake
-        with:
-          cmake_preset: msvc-${{ matrix.cxx_version }}-${{ matrix.build_type == 'Debug' && 'debug' || 'release' }}
-          extra_cmake_configure_args: ${{ matrix.generator_override }}
-          extra_cmake_build_args: ${{ matrix.toolset == 'ClangCL' && format('--config {0}', matrix.build_type) || '' }}
-          extra_ctest_args: ${{ matrix.toolset == 'ClangCL' && format('-C {0}', matrix.build_type) || '' }}

.github/workflows/copilot-setup-steps.yml

@@ -1,21 +0,0 @@
-name: "Copilot Setup Steps"
-
-on: workflow_dispatch
-
-jobs:
-  copilot-setup-steps:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v6
-
-      - name: Install Build Dependencies
-        run: sudo apt-get update && sudo apt-get install -y clang cmake make
-
-      - name: Configure CMake (C++14)
-        run: cmake --preset clang-14-debug
-
-      - name: Configure CMake (C++20)
-        run: cmake --preset clang-20-debug

.github/workflows/ios.yml

@@ -12,7 +12,7 @@ jobs:
       run:
         working-directory: build
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v2
 
       - name: Create build directory
         run: mkdir -p build
@@ -25,12 +25,11 @@ jobs:
             -GXcode \
             -DCMAKE_SYSTEM_NAME=iOS \
             "-DCMAKE_OSX_ARCHITECTURES=arm64;x86_64" \
-            -DCMAKE_OSX_DEPLOYMENT_TARGET=12.0 \
+            -DCMAKE_OSX_DEPLOYMENT_TARGET=9 \
             -DCMAKE_TRY_COMPILE_TARGET_TYPE=STATIC_LIBRARY \
             "-DMACOSX_BUNDLE_GUI_IDENTIFIER=GSL.\$(EXECUTABLE_NAME)" \
-            -DMACOSX_BUNDLE_BUNDLE_VERSION=4.2.0 \
-            -DMACOSX_BUNDLE_SHORT_VERSION_STRING=4.2.0 \
-            -DCMAKE_CXX_FLAGS="-Wno-missing-include-dirs" \
+            -DMACOSX_BUNDLE_BUNDLE_VERSION=3.1.0 \
+            -DMACOSX_BUNDLE_SHORT_VERSION_STRING=3.1.0 \
             ..
 
       - name: Build

.github/workflows/shell-script-linter.yml

@@ -1,32 +0,0 @@
-name: Shell script linter
-
-on:
-  push:
-    branches: [ main ]
-  pull_request:
-    branches: [ main ]
-
-permissions:
-  contents: read
-
-jobs:
-  clang-format:
-    name: Run shfmt and shellcheck
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-
-      # Install the needed binaries
-      - name: Install shfmt and shellcheck
-        run: |
-          sudo apt install shfmt shellcheck
-
-      - name: Check format
-        run: |
-          find scripts -type f -name '*.sh' -exec shfmt -l {} \;
-
-      - name: Run shellcheck
-        run: |
-          find scripts -type f -name '*.sh' -exec shellcheck {} \;

.gitignore

@@ -1,5 +1,5 @@
 CMakeFiles
-build*/
+build
 tests/CMakeFiles
 tests/Debug
 *.opensdf

CMakeLists.txt

@@ -1,48 +1,61 @@
-cmake_minimum_required(VERSION 3.14...3.16)
+cmake_minimum_required(VERSION 3.1.3...3.16)
 
-project(GSL VERSION 4.2.0 LANGUAGES CXX)
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/")
+include(guidelineSupportLibrary)
 
+project(GSL
+    VERSION 4.0.0
+    LANGUAGES CXX
+)
+
+# Must include after the project call due to GNUInstallDirs requiring a language be enabled (IE. CXX)
+include(GNUInstallDirs)
+
+# 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)
 
-# https://cmake.org/cmake/help/latest/variable/PROJECT_IS_TOP_LEVEL.html
-string(COMPARE EQUAL ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_SOURCE_DIR} PROJECT_IS_TOP_LEVEL)
+# 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()
 
-option(GSL_INSTALL "Generate and install GSL target" ${PROJECT_IS_TOP_LEVEL})
-option(GSL_TEST "Build and perform GSL tests" ${PROJECT_IS_TOP_LEVEL})
+### Project options
+option(GSL_INSTALL "Generate and install GSL target" ${GSL_STANDALONE_PROJECT})
+option(GSL_TEST "Build and perform GSL tests" ${GSL_STANDALONE_PROJECT})
 
-# The implementation generally assumes a platform that implements C++14 support
-target_compile_features(GSL INTERFACE "cxx_std_14")
+# This GSL implementation generally assumes a platform that implements C++14 support.
+set(gsl_min_cxx_standard "14")
+
+if (GSL_STANDALONE_PROJECT)
+    gsl_set_default_cxx_standard(${gsl_min_cxx_standard})
+else()
+    gsl_client_set_cxx_standard(${gsl_min_cxx_standard})
+endif()
 
 # Setup include directory
 add_subdirectory(include)
 
-target_sources(GSL INTERFACE $<BUILD_INTERFACE:${GSL_SOURCE_DIR}/GSL.natvis>)
+# Add natvis file
+gsl_add_native_visualizer_support()
+
+# Add packaging support
+gsl_create_packaging_file()
+
+if (GSL_INSTALL)
+    # Setup install/export logic
+    gsl_install_logic()
+endif()
 
 if (GSL_TEST)
     enable_testing()
     add_subdirectory(tests)
 endif()
-
-if (GSL_INSTALL)
-    include(GNUInstallDirs)
-    include(CMakePackageConfigHelpers)
-
-    install(DIRECTORY "${PROJECT_SOURCE_DIR}/include/gsl" DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
-
-    set(export_name "Microsoft.GSLConfig")
-    set(namespace "Microsoft.GSL::")
-    set(cmake_files_install_dir ${CMAKE_INSTALL_DATADIR}/cmake/Microsoft.GSL)
-
-    install(TARGETS GSL EXPORT ${export_name} INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
-    install(EXPORT ${export_name} NAMESPACE ${namespace} DESTINATION ${cmake_files_install_dir})
-    export(TARGETS GSL NAMESPACE ${namespace} FILE ${export_name}.cmake)
-
-    set(gls_config_version "${CMAKE_CURRENT_BINARY_DIR}/Microsoft.GSLConfigVersion.cmake")
-
-    write_basic_package_version_file(${gls_config_version} COMPATIBILITY SameMajorVersion ARCH_INDEPENDENT)
-
-    install(FILES ${gls_config_version} DESTINATION ${cmake_files_install_dir})
-
-    install(FILES GSL.natvis DESTINATION ${cmake_files_install_dir})
-endif()

CMakePresets.json

@@ -1,459 +0,0 @@
-{
-    "version": 3,
-    "configurePresets": [
-        {
-            "name": "base",
-            "hidden": true,
-            "binaryDir": "${sourceDir}/build/${presetName}",
-            "installDir": "${sourceDir}/install/${presetName}",
-            "generator": "Ninja",
-            "cacheVariables": {
-                "GSL_CXX_STANDARD": "14",
-                "GSL_TEST": "ON"
-            }
-        },
-        {
-            "name": "msvc-base",
-            "inherits": "base",
-            "hidden": true,
-            "condition": {
-                "type": "equals",
-                "lhs": "${hostSystemName}",
-                "rhs": "Windows"
-            },
-            "cacheVariables": {
-                "CMAKE_CXX_COMPILER": "cl"
-            }
-        },
-        {
-            "name": "gcc-base",
-            "inherits": "base",
-            "hidden": true,
-            "cacheVariables": {
-                "CMAKE_CXX_COMPILER": "g++",
-                "CMAKE_C_COMPILER": "gcc"
-            }
-        },
-        {
-            "name": "clang-base",
-            "inherits": "base",
-            "hidden": true,
-            "cacheVariables": {
-                "CMAKE_CXX_COMPILER": "clang++",
-                "CMAKE_C_COMPILER": "clang"
-            }
-        },
-        {
-            "name": "msvc-14-debug",
-            "displayName": "MSVC C++14 Debug",
-            "inherits": "msvc-base",
-            "cacheVariables": {
-                "CMAKE_BUILD_TYPE": "Debug",
-                "GSL_CXX_STANDARD": "14"
-            }
-        },
-        {
-            "name": "msvc-14-release",
-            "displayName": "MSVC C++14 Release",
-            "inherits": "msvc-base",
-            "cacheVariables": {
-                "CMAKE_BUILD_TYPE": "Release",
-                "GSL_CXX_STANDARD": "14"
-            }
-        },
-        {
-            "name": "msvc-17-debug",
-            "displayName": "MSVC C++17 Debug",
-            "inherits": "msvc-base",
-            "cacheVariables": {
-                "CMAKE_BUILD_TYPE": "Debug",
-                "GSL_CXX_STANDARD": "17"
-            }
-        },
-        {
-            "name": "msvc-17-release",
-            "displayName": "MSVC C++17 Release",
-            "inherits": "msvc-base",
-            "cacheVariables": {
-                "CMAKE_BUILD_TYPE": "Release",
-                "GSL_CXX_STANDARD": "17"
-            }
-        },
-        {
-            "name": "msvc-20-debug",
-            "displayName": "MSVC C++20 Debug",
-            "inherits": "msvc-base",
-            "cacheVariables": {
-                "CMAKE_BUILD_TYPE": "Debug",
-                "GSL_CXX_STANDARD": "20"
-            }
-        },
-        {
-            "name": "msvc-20-release",
-            "displayName": "MSVC C++20 Release",
-            "inherits": "msvc-base",
-            "cacheVariables": {
-                "CMAKE_BUILD_TYPE": "Release",
-                "GSL_CXX_STANDARD": "20"
-            }
-        },
-        {
-            "name": "msvc-23-debug",
-            "displayName": "MSVC C++23 Debug",
-            "inherits": "msvc-base",
-            "cacheVariables": {
-                "CMAKE_BUILD_TYPE": "Debug",
-                "GSL_CXX_STANDARD": "23"
-            }
-        },
-        {
-            "name": "msvc-23-release",
-            "displayName": "MSVC C++23 Release",
-            "inherits": "msvc-base",
-            "cacheVariables": {
-                "CMAKE_BUILD_TYPE": "Release",
-                "GSL_CXX_STANDARD": "23"
-            }
-        },
-        {
-            "name": "gcc-14-debug",
-            "displayName": "GCC C++14 Debug",
-            "inherits": "gcc-base",
-            "cacheVariables": {
-                "CMAKE_BUILD_TYPE": "Debug",
-                "GSL_CXX_STANDARD": "14"
-            }
-        },
-        {
-            "name": "gcc-14-release",
-            "displayName": "GCC C++14 Release",
-            "inherits": "gcc-base",
-            "cacheVariables": {
-                "CMAKE_BUILD_TYPE": "Release",
-                "GSL_CXX_STANDARD": "14"
-            }
-        },
-        {
-            "name": "gcc-17-debug",
-            "displayName": "GCC C++17 Debug",
-            "inherits": "gcc-base",
-            "cacheVariables": {
-                "CMAKE_BUILD_TYPE": "Debug",
-                "GSL_CXX_STANDARD": "17"
-            }
-        },
-        {
-            "name": "gcc-17-release",
-            "displayName": "GCC C++17 Release",
-            "inherits": "gcc-base",
-            "cacheVariables": {
-                "CMAKE_BUILD_TYPE": "Release",
-                "GSL_CXX_STANDARD": "17"
-            }
-        },
-        {
-            "name": "gcc-20-debug",
-            "displayName": "GCC C++20 Debug",
-            "inherits": "gcc-base",
-            "cacheVariables": {
-                "CMAKE_BUILD_TYPE": "Debug",
-                "GSL_CXX_STANDARD": "20"
-            }
-        },
-        {
-            "name": "gcc-20-release",
-            "displayName": "GCC C++20 Release",
-            "inherits": "gcc-base",
-            "cacheVariables": {
-                "CMAKE_BUILD_TYPE": "Release",
-                "GSL_CXX_STANDARD": "20"
-            }
-        },
-        {
-            "name": "gcc-23-debug",
-            "displayName": "GCC C++23 Debug",
-            "inherits": "gcc-base",
-            "cacheVariables": {
-                "CMAKE_BUILD_TYPE": "Debug",
-                "GSL_CXX_STANDARD": "23"
-            }
-        },
-        {
-            "name": "gcc-23-release",
-            "displayName": "GCC C++23 Release",
-            "inherits": "gcc-base",
-            "cacheVariables": {
-                "CMAKE_BUILD_TYPE": "Release",
-                "GSL_CXX_STANDARD": "23"
-            }
-        },
-        {
-            "name": "clang-14-debug",
-            "displayName": "Clang C++14 Debug",
-            "inherits": "clang-base",
-            "cacheVariables": {
-                "CMAKE_BUILD_TYPE": "Debug",
-                "GSL_CXX_STANDARD": "14"
-            }
-        },
-        {
-            "name": "clang-14-release",
-            "displayName": "Clang C++14 Release",
-            "inherits": "clang-base",
-            "cacheVariables": {
-                "CMAKE_BUILD_TYPE": "Release",
-                "GSL_CXX_STANDARD": "14"
-            }
-        },
-        {
-            "name": "clang-17-debug",
-            "displayName": "Clang C++17 Debug",
-            "inherits": "clang-base",
-            "cacheVariables": {
-                "CMAKE_BUILD_TYPE": "Debug",
-                "GSL_CXX_STANDARD": "17"
-            }
-        },
-        {
-            "name": "clang-17-release",
-            "displayName": "Clang C++17 Release",
-            "inherits": "clang-base",
-            "cacheVariables": {
-                "CMAKE_BUILD_TYPE": "Release",
-                "GSL_CXX_STANDARD": "17"
-            }
-        },
-        {
-            "name": "clang-20-debug",
-            "displayName": "Clang C++20 Debug",
-            "inherits": "clang-base",
-            "cacheVariables": {
-                "CMAKE_BUILD_TYPE": "Debug",
-                "GSL_CXX_STANDARD": "20"
-            }
-        },
-        {
-            "name": "clang-20-release",
-            "displayName": "Clang C++20 Release",
-            "inherits": "clang-base",
-            "cacheVariables": {
-                "CMAKE_BUILD_TYPE": "Release",
-                "GSL_CXX_STANDARD": "20"
-            }
-        },
-        {
-            "name": "clang-23-debug",
-            "displayName": "Clang C++23 Debug",
-            "inherits": "clang-base",
-            "cacheVariables": {
-                "CMAKE_BUILD_TYPE": "Debug",
-                "GSL_CXX_STANDARD": "23"
-            }
-        },
-        {
-            "name": "clang-23-release",
-            "displayName": "Clang C++23 Release",
-            "inherits": "clang-base",
-            "cacheVariables": {
-                "CMAKE_BUILD_TYPE": "Release",
-                "GSL_CXX_STANDARD": "23"
-            }
-        }
-    ],
-    "buildPresets": [
-        {
-            "name": "msvc-14-debug",
-            "configurePreset": "msvc-14-debug"
-        },
-        {
-            "name": "msvc-14-release",
-            "configurePreset": "msvc-14-release"
-        },
-        {
-            "name": "msvc-17-debug",
-            "configurePreset": "msvc-17-debug"
-        },
-        {
-            "name": "msvc-17-release",
-            "configurePreset": "msvc-17-release"
-        },
-        {
-            "name": "msvc-20-debug",
-            "configurePreset": "msvc-20-debug"
-        },
-        {
-            "name": "msvc-20-release",
-            "configurePreset": "msvc-20-release"
-        },
-        {
-            "name": "msvc-23-debug",
-            "configurePreset": "msvc-23-debug"
-        },
-        {
-            "name": "msvc-23-release",
-            "configurePreset": "msvc-23-release"
-        },
-        {
-            "name": "gcc-14-debug",
-            "configurePreset": "gcc-14-debug"
-        },
-        {
-            "name": "gcc-14-release",
-            "configurePreset": "gcc-14-release"
-        },
-        {
-            "name": "gcc-17-debug",
-            "configurePreset": "gcc-17-debug"
-        },
-        {
-            "name": "gcc-17-release",
-            "configurePreset": "gcc-17-release"
-        },
-        {
-            "name": "gcc-20-debug",
-            "configurePreset": "gcc-20-debug"
-        },
-        {
-            "name": "gcc-20-release",
-            "configurePreset": "gcc-20-release"
-        },
-        {
-            "name": "gcc-23-debug",
-            "configurePreset": "gcc-23-debug"
-        },
-        {
-            "name": "gcc-23-release",
-            "configurePreset": "gcc-23-release"
-        },
-        {
-            "name": "clang-14-debug",
-            "configurePreset": "clang-14-debug"
-        },
-        {
-            "name": "clang-14-release",
-            "configurePreset": "clang-14-release"
-        },
-        {
-            "name": "clang-17-debug",
-            "configurePreset": "clang-17-debug"
-        },
-        {
-            "name": "clang-17-release",
-            "configurePreset": "clang-17-release"
-        },
-        {
-            "name": "clang-20-debug",
-            "configurePreset": "clang-20-debug"
-        },
-        {
-            "name": "clang-20-release",
-            "configurePreset": "clang-20-release"
-        },
-        {
-            "name": "clang-23-debug",
-            "configurePreset": "clang-23-debug"
-        },
-        {
-            "name": "clang-23-release",
-            "configurePreset": "clang-23-release"
-        }
-    ],
-    "testPresets": [
-        {
-            "name": "msvc-14-debug",
-            "configurePreset": "msvc-14-debug"
-        },
-        {
-            "name": "msvc-14-release",
-            "configurePreset": "msvc-14-release"
-        },
-        {
-            "name": "msvc-17-debug",
-            "configurePreset": "msvc-17-debug"
-        },
-        {
-            "name": "msvc-17-release",
-            "configurePreset": "msvc-17-release"
-        },
-        {
-            "name": "msvc-20-debug",
-            "configurePreset": "msvc-20-debug"
-        },
-        {
-            "name": "msvc-20-release",
-            "configurePreset": "msvc-20-release"
-        },
-        {
-            "name": "msvc-23-debug",
-            "configurePreset": "msvc-23-debug"
-        },
-        {
-            "name": "msvc-23-release",
-            "configurePreset": "msvc-23-release"
-        },
-        {
-            "name": "gcc-14-debug",
-            "configurePreset": "gcc-14-debug"
-        },
-        {
-            "name": "gcc-14-release",
-            "configurePreset": "gcc-14-release"
-        },
-        {
-            "name": "gcc-17-debug",
-            "configurePreset": "gcc-17-debug"
-        },
-        {
-            "name": "gcc-17-release",
-            "configurePreset": "gcc-17-release"
-        },
-        {
-            "name": "gcc-20-debug",
-            "configurePreset": "gcc-20-debug"
-        },
-        {
-            "name": "gcc-20-release",
-            "configurePreset": "gcc-20-release"
-        },
-        {
-            "name": "gcc-23-debug",
-            "configurePreset": "gcc-23-debug"
-        },
-        {
-            "name": "gcc-23-release",
-            "configurePreset": "gcc-23-release"
-        },
-        {
-            "name": "clang-14-debug",
-            "configurePreset": "clang-14-debug"
-        },
-        {
-            "name": "clang-14-release",
-            "configurePreset": "clang-14-release"
-        },
-        {
-            "name": "clang-17-debug",
-            "configurePreset": "clang-17-debug"
-        },
-        {
-            "name": "clang-17-release",
-            "configurePreset": "clang-17-release"
-        },
-        {
-            "name": "clang-20-debug",
-            "configurePreset": "clang-20-debug"
-        },
-        {
-            "name": "clang-20-release",
-            "configurePreset": "clang-20-release"
-        },
-        {
-            "name": "clang-23-debug",
-            "configurePreset": "clang-23-debug"
-        },
-        {
-            "name": "clang-23-release",
-            "configurePreset": "clang-23-release"
-        }
-    ]
-}

CMakeSettings.json

@@ -0,0 +1,18 @@
+{
+  "configurations": [
+    {
+      "name": "x64-Debug",
+      "generator": "Ninja",
+      "configurationType": "Debug",
+      "inheritEnvironments": [
+        "msvc_x64_x64"
+      ],
+      "buildRoot": "${env.USERPROFILE}\\CMakeBuilds\\${workspaceHash}\\build\\${name}",
+      "installRoot": "${env.USERPROFILE}\\CMakeBuilds\\${workspaceHash}\\install\\${name}",
+      "cmakeCommandArgs": "-DGSL_CXX_STANDARD=17",
+      "buildCommandArgs": "-v",
+      "ctestCommandArgs": "",
+      "codeAnalysisRuleset": "CppCoreCheckRules.ruleset"
+    }
+  ]
+}

GSL.natvis

@@ -4,7 +4,13 @@
     vim: syntax=xml
 -->
 <AutoVisualizer xmlns="http://schemas.microsoft.com/vstudio/debugger/natvis/2010">
-    <!-- These types are from the util header. -->
+    <!-- These types are from the gsl_assert header. -->
+    <Type Name="gsl::fail_fast">
+        <!-- na hides the address, otherwise it would appear as 0x.... "Message" -->
+        <DisplayString>{_Data._What,nasb}</DisplayString>
+    </Type>
+
+    <!-- These types are from the gsl_util header. -->
     <Type Name="gsl::final_action&lt;*&gt;">
         <DisplayString>{{ invoke = {invoke_}, action = {f_} }}</DisplayString>
         <Expand>
@@ -13,8 +19,7 @@
         </Expand>
     </Type>
 
-  <!-- These types are from the span header. -->
-  <Type Name="gsl::span&lt;*, *&gt;">
+    <Type Name="gsl::span&lt;*, *&gt;">
         <DisplayString>{{ extent = {storage_.size_} }}</DisplayString>
         <Expand>
             <ArrayItems>
@@ -24,7 +29,29 @@
         </Expand>
     </Type>
 
-    <!-- These types are from the pointers header. -->
+    <Type Name="gsl::basic_string_span&lt;*, *&gt;">
+        <DisplayString>{span_.storage_.data_,[span_.storage_.size_]na}</DisplayString>
+        <Expand>
+            <Item Name="[size]">span_.storage_.size_</Item>
+            <ArrayItems>
+                <Size>span_.storage_.size_</Size>
+                <ValuePointer>span_.storage_.data_</ValuePointer>
+            </ArrayItems>
+        </Expand>
+    </Type>
+
+    <Type Name="gsl::basic_zstring_span&lt;*, *&gt;">
+        <DisplayString>{span_.storage_.data_,[span_.storage_.size_]na}</DisplayString>
+        <Expand>
+            <Item Name="[size]">span_.storage_.size_</Item>
+            <ArrayItems>
+                <Size>span_.storage_.size_</Size>
+                <ValuePointer>span_.storage_.data_</ValuePointer>
+            </ArrayItems>
+        </Expand>
+    </Type>
+
+    <!-- These types are from the gsl header. -->
     <Type Name="gsl::not_null&lt;*&gt;">
         <!-- We can always dereference this since it's an invariant. -->
         <DisplayString>value = {*ptr_}</DisplayString>

README.md

@@ -1,6 +1,5 @@
 # GSL: Guidelines Support Library
-[![CI](https://github.com/Microsoft/GSL/actions/workflows/compilers.yml/badge.svg)](https://github.com/microsoft/GSL/actions/workflows/compilers.yml?query=branch%3Amain)
-[![vcpkg](https://img.shields.io/vcpkg/v/ms-gsl)](https://vcpkg.io/en/package/ms-gsl)
+[![Build Status](https://dev.azure.com/cppstat/GSL/_apis/build/status/microsoft.GSL?branchName=main)](https://dev.azure.com/cppstat/GSL/_build/latest?definitionId=1&branchName=main)
 
 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).
@@ -23,63 +22,59 @@ This project makes use of the [Google Test](https://github.com/google/googletest
 # Supported features
 ## Microsoft GSL implements the following from the C++ Core Guidelines:
 
-Feature                                                                  | Supported? | Description
--------------------------------------------------------------------------|:----------:|-------------
-[**1. Views**][cg-views]                                                 |            |
-[owner](docs/headers.md#user-content-H-pointers-owner)                   | ☑   | An alias for a raw pointer
-[not_null](docs/headers.md#user-content-H-pointers-not_null)             | ☑   | Restricts a pointer/smart pointer to hold non-null values
-[span](docs/headers.md#user-content-H-span-span)                         | ☑   | A view over a contiguous sequence of memory. Based on the standardized version of `std::span`, however `gsl::span` enforces bounds checking.
-span_p                                                                   | ☐   | Spans a range starting from a pointer to the first place for which the predicate is true
-[basic_zstring](docs/headers.md#user-content-H-zstring)                  | ☑   | A pointer to a C-string (zero-terminated array) with a templated char type
-[zstring](docs/headers.md#user-content-H-zstring)                        | ☑   | An alias to `basic_zstring` with dynamic extent and a char type of `char`
-[czstring](docs/headers.md#user-content-H-zstring)                       | ☑   | An alias to `basic_zstring` with dynamic extent and a char type of `const char`
-[wzstring](docs/headers.md#user-content-H-zstring)                       | ☑   | An alias to `basic_zstring` with dynamic extent and a char type of `wchar_t`
-[cwzstring](docs/headers.md#user-content-H-zstring)                      | ☑   | An alias to `basic_zstring` with dynamic extent and a char type of `const wchar_t`
-[u16zstring](docs/headers.md#user-content-H-zstring)                     | ☑   | An alias to `basic_zstring` with dynamic extent and a char type of `char16_t`
-[cu16zstring](docs/headers.md#user-content-H-zstring)                    | ☑   | An alias to `basic_zstring` with dynamic extent and a char type of `const char16_t`
-[u32zstring](docs/headers.md#user-content-H-zstring)                     | ☑   | An alias to `basic_zstring` with dynamic extent and a char type of `char32_t`
-[cu32zstring](docs/headers.md#user-content-H-zstring)                    | ☑   | An alias to `basic_zstring` with dynamic extent and a char type of `const char32_t`
-[**2. Owners**][cg-owners]                                               |            |
-stack_array                                                              | ☐   | A stack-allocated array
-dyn_array                                                                | ☑   | A heap-allocated array
-[**3. Assertions**][cg-assertions]                                       |            |
-[Expects](docs/headers.md#user-content-H-assert-expects)                 | ☑   | A precondition assertion; on failure it terminates
-[Ensures](docs/headers.md#user-content-H-assert-ensures)                 | ☑   | A postcondition assertion; on failure it terminates
-[**4. Utilities**][cg-utilities]                                         |            |
-move_owner                                                               | ☐   | A helper function that moves one `owner` to the other
-[final_action](docs/headers.md#user-content-H-util-final_action)         | ☑   | A RAII style class that invokes a functor on its destruction
-[finally](docs/headers.md#user-content-H-util-finally)                   | ☑   | A helper function instantiating [final_action](docs/headers.md#user-content-H-util-final_action)
-[GSL_SUPPRESS](docs/headers.md#user-content-H-assert-gsl_suppress)       | ☑   | A macro that takes an argument and turns it into `[[gsl::suppress(x)]]` or `[[gsl::suppress("x")]]` depending on the compiler.
-[[implicit]]                                                             | ☐   | A "marker" to put on single-argument constructors to explicitly make them non-explicit
-[index](docs/headers.md#user-content-H-util-index)                       | ☑   | A type to use for all container and array indexing (currently an alias for `std::ptrdiff_t`)
-[narrow](docs/headers.md#user-content-H-narrow-narrow)                   | ☑   | A checked version of `narrow_cast`; it can throw [narrowing_error](docs/headers.md#user-content-H-narrow-narrowing_error)
-[narrow_cast](docs/headers.md#user-content-H-util-narrow_cast)           | ☑   | A narrowing cast for values and a synonym for `static_cast`
-[narrowing_error](docs/headers.md#user-content-H-narrow-narrowing_error) | ☑   | A custom exception type thrown by [narrow](docs/headers.md#user-content-H-narrow-narrow)
-[**5. Concepts**][cg-concepts]                                           | ☐   |
+Feature                            | Supported? | Description
+-----------------------------------|:----------:|-------------
+[**1. Views**][cg-views]           |            |
+owner                              | ☑   | an alias for a raw pointer
+not_null                           | ☑   | restricts a pointer / smart pointer to hold non-null values
+span                               | ☑   | 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                             | ☐   | spans a range starting from a pointer to the first place for which the predicate is true
+basic_zstring                      | ☑   | A pointer to a C-string (zero-terminated array) with a templated char type
+zstring                            | ☑   | An alias to `basic_zstring` with dynamic extent and a char type of char
+czstring                           | ☑   | An alias to `basic_zstring` with dynamic extent and a char type of const char
+wzstring                           | ☑   | An alias to `basic_zstring` with dynamic extent and a char type of wchar_t
+cwzstring                          | ☑   | An alias to `basic_zstring` with dynamic extent and a char type of const wchar_t
+u16zstring                         | ☑   | An alias to `basic_zstring` with dynamic extent and a char type of char16_t
+cu16zstring                        | ☑   | An alias to `basic_zstring` with dynamic extent and a char type of const char16_t
+u32zstring                         | ☑   | An alias to `basic_zstring` with dynamic extent and a char type of char32_t
+cu32zstring                        | ☑   | An alias to `basic_zstring` with dynamic extent and a char type of const char32_t
+[**2. Owners**][cg-owners]         |            |
+unique_ptr                         | ☑   | an alias to `std::unique_ptr`
+shared_ptr                         | ☑   | an alias to `std::shared_ptr`
+stack_array                        | ☐   | a stack-allocated array
+dyn_array                          | ☐   | a heap-allocated array
+[**3. Assertions**][cg-assertions] |            |
+Expects                            | ☑   | a precondition assertion; on failure it terminates
+Ensures                            | ☑   | a postcondition assertion; on failure it terminates
+[**4. Utilities**][cg-utilities]   |            |
+move_owner                         | ☐   | a helper function that moves one `owner` to the other
+byte                               | ☑   | either an alias to std::byte or a byte type
+final_action                       | ☑   | a RAII style class that invokes a functor on its destruction
+finally                            | ☑   | a helper function instantiating `final_action`
+GSL_SUPPRESS                       | ☑   | a macro that takes an argument and turns it into `[[gsl::suppress(x)]]` or `[[gsl::suppress("x")]]`
+[[implicit]]                       | ☐   | a "marker" to put on single-argument constructors to explicitly make them non-explicit
+index                              | ☑   | a type to use for all container and array indexing (currently an alias for std::ptrdiff_t)
+joining_thread                     | ☐   | a RAII style version of `std::thread` that joins
+narrow                             | ☑   | a checked version of narrow_cast; it can throw `narrowing_error`
+narrow_cast                        | ☑   | a narrowing cast for values and a synonym for static_cast
+narrowing_error                    | ☑   | a custom exception type thrown by `narrow()`
+[**5. Concepts**][cg-concepts]     | ☐   |
 
 ## The following features do not exist in or have been removed from the C++ Core Guidelines:
 Feature                            | Supported? | Description
 -----------------------------------|:----------:|-------------
-[strict_not_null](docs/headers.md#user-content-H-pointers-strict_not_null) | ☑   | A stricter version of [not_null](docs/headers.md#user-content-H-pointers-not_null) with explicit constructors
+strict_not_null                    | ☑   | A stricter version of `not_null` with explicit constructors
 multi_span                         | ☐   | Deprecated. Multi-dimensional span.
 strided_span                       | ☐   | Deprecated. Support for this type has been discontinued.
 basic_string_span                  | ☐   | Deprecated. Like `span` but for strings with a templated char type
-string_span                        | ☐   | Deprecated. An alias to `basic_string_span` with a char type of `char`
-cstring_span                       | ☐   | Deprecated. An alias to `basic_string_span` with a char type of `const char`
-wstring_span                       | ☐   | Deprecated. An alias to `basic_string_span` with a char type of `wchar_t`
-cwstring_span                      | ☐   | Deprecated. An alias to `basic_string_span` with a char type of `const wchar_t`
-u16string_span                     | ☐   | Deprecated. An alias to `basic_string_span` with a char type of `char16_t`
-cu16string_span                    | ☐   | Deprecated. An alias to `basic_string_span` with a char type of `const char16_t`
-u32string_span                     | ☐   | Deprecated. An alias to `basic_string_span` with a char type of `char32_t`
-cu32string_span                    | ☐   | Deprecated. An alias to `basic_string_span` with a char type of `const char32_t`
-
-## The following features have been adopted by WG21. They are deprecated in GSL.
-Feature                                                           | Deprecated Since | Notes
-------------------------------------------------------------------|------------------|------
-[unique_ptr](docs/headers.md#user-content-H-pointers-unique_ptr)  | C++11            | Use std::unique_ptr instead.
-[shared_ptr](docs/headers.md#user-content-H-pointers-shared_ptr)  | C++11            | Use std::shared_ptr instead.
-[byte](docs/headers.md#user-content-H-byte-byte)                  | C++17            | Use std::byte instead.
-joining_thread                                                    | C++20 (Note: Not yet implemented in GSL) | Use std::jthread instead.
+string_span                        | ☐   | Deprecated. An alias to `basic_string_span` with a char type of char
+cstring_span                       | ☐   | Deprecated. An alias to `basic_string_span` with a char type of const char
+wstring_span                       | ☐   | Deprecated. An alias to `basic_string_span` with a char type of wchar_t
+cwstring_span                      | ☐   | Deprecated. An alias to `basic_string_span` with a char type of const wchar_t
+u16string_span                     | ☐   | Deprecated. An alias to `basic_string_span` with a char type of char16_t
+cu16string_span                    | ☐   | Deprecated. An alias to `basic_string_span` with a char type of const char16_t
+u32string_span                     | ☐   | Deprecated. An alias to `basic_string_span` with a char type of char32_t
+cu32string_span                    | ☐   | Deprecated. An alias to `basic_string_span` with a char type of const char32_t
 
 This is based on [CppCoreGuidelines semi-specification](https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#gsl-guidelines-support-library).
 
@@ -91,17 +86,24 @@ This is based on [CppCoreGuidelines semi-specification](https://github.com/isocp
 
 # Quick Start
 ## Supported Compilers / Toolsets
-The GSL officially supports recent major versions of Visual Studio with both MSVC and LLVM, GCC, Clang, and XCode with Apple-Clang.
-For each of these major versions, the GSL officially supports C++14, C++17, C++20, and C++23 (when supported by the compiler).
-Below is a table showing the versions currently being tested (also see [.github/workflows/compilers.yml](the workflow).)
+The GSL officially supports the latest and previous major versions of VS with MSVC & LLVM, GCC, Clang, and XCode with Apple-Clang.
+Within these two major versions, we try to target the latest minor updates / revisions (although this may be affected by
+delays between a toolchain's release and when it becomes widely available for use).
+Below is a table showing the versions currently being tested.
 
 Compiler |Toolset Versions Currently Tested
 :------- |--:
- GCC | 12, 13, 14
- XCode | 14.3.1, 15.4
- Clang | 16, 17, 18
- Visual Studio with MSVC | VS2019, VS2022 
- Visual Studio with LLVM | VS2019, VS2022
+ XCode | 13.2.1 & 12.5.1
+ GCC | 11[^1] & 10[^2]
+ Clang | 12[^2] & 11[^2]
+ Visual Studio with MSVC | VS2022[^3] & VS2019[^4]
+ Visual Studio with LLVM | VS2022[^3] & VS2019[^4]
+
+
+[^1]: Precise version may be found in the [latest CI results](https://dev.azure.com/cppstat/GSL/_build?definitionId=1&branchFilter=26).
+[^2]: Precise version may be found in the [latest CI results](https://dev.azure.com/cppstat/GSL/_build?definitionId=1&branchFilter=26). Should be the version specified [here](https://github.com/actions/virtual-environments/blob/main/images/linux/Ubuntu2004-Readme.md#language-and-runtime).
+[^3]: Precise version may be found in the [latest CI results](https://dev.azure.com/cppstat/GSL/_build?definitionId=1&branchFilter=26). Should be the version specified [here](https://github.com/actions/virtual-environments/blob/main/images/win/Windows2022-Readme.md#visual-studio-enterprise-2022).
+[^4]: Precise version may be found in the [latest CI results](https://dev.azure.com/cppstat/GSL/_build?definitionId=1&branchFilter=26). Should be the version specified [here](https://github.com/actions/virtual-environments/blob/main/images/win/Windows2019-Readme.md#visual-studio-enterprise-2019).
 
 ---
 If you successfully port GSL to another platform, we would love to hear from you!
@@ -111,19 +113,19 @@ If you successfully port GSL to another platform, we would love to hear from you
 
 Target | CI/CD Status
 :------- | -----------:
-iOS | [![CI_iOS](https://github.com/microsoft/GSL/workflows/CI_iOS/badge.svg?branch=main)](https://github.com/microsoft/GSL/actions/workflows/ios.yml?query=branch%3Amain)
-Android | [![CI_Android](https://github.com/microsoft/GSL/workflows/CI_Android/badge.svg?branch=main)](https://github.com/microsoft/GSL/actions/workflows/android.yml?query=branch%3Amain)
+iOS | ![CI_iOS](https://github.com/microsoft/GSL/workflows/CI_iOS/badge.svg)
+Android | ![CI_Android](https://github.com/microsoft/GSL/workflows/CI_Android/badge.svg)
 
 Note: These CI/CD steps are run with each pull request, however failures in them are non-blocking.
 
 ## Building the tests
 To build the tests, you will require the following:
 
-* [CMake](http://cmake.org), version 3.14 or later to be installed and in your PATH.
+* [CMake](http://cmake.org), version 3.1.3 (3.2.3 for AppleClang) or later to be installed and in your PATH.
 
 These steps assume the source code of this repository has been cloned into a directory named `c:\GSL`.
 
-1. Create a directory to contain the build outputs for a particular architecture (we name it `c:\GSL\build-x86` in this example).
+1. Create a directory to contain the build outputs for a particular architecture (we name it c:\GSL\build-x86 in this example).
 
         cd GSL
         md build-x86
@@ -177,44 +179,43 @@ Include the library using:
 
 ## Usage in CMake
 
-The library provides a Config file for CMake, once installed it can be found via `find_package`.
+The library provides a Config file for CMake, once installed it can be found via
+
+    find_package(Microsoft.GSL CONFIG)
 
 Which, when successful, will add library target called `Microsoft.GSL::GSL` which you can use via the usual
 `target_link_libraries` mechanism.
 
-```cmake
-find_package(Microsoft.GSL CONFIG REQUIRED)
-
-target_link_libraries(foobar PRIVATE Microsoft.GSL::GSL)
-```
-
 ### FetchContent
 
-If you are using CMake version 3.11+ you can use the official [FetchContent module](https://cmake.org/cmake/help/latest/module/FetchContent.html).
+If you are using cmake version 3.11+ you can use the offical FetchContent module.
 This allows you to easily incorporate GSL into your project.
 
 ```cmake
-# NOTE: This example uses CMake version 3.14 (FetchContent_MakeAvailable).
+# NOTE: This example uses cmake version 3.14 (FetchContent_MakeAvailable).
 # Since it streamlines the FetchContent process
 cmake_minimum_required(VERSION 3.14)
 
 include(FetchContent)
 
+# In this example we are picking a specific tag.
+# You can also pick a specific commit, if you need to.
 FetchContent_Declare(GSL
     GIT_REPOSITORY "https://github.com/microsoft/GSL"
-    GIT_TAG "v4.2.0"
-    GIT_SHALLOW ON
+    GIT_TAG "v3.1.0"
 )
 
 FetchContent_MakeAvailable(GSL)
 
-target_link_libraries(foobar PRIVATE Microsoft.GSL::GSL)
+# Now you can link against the GSL interface library
+add_executable(foobar)
+
+# Link against the interface library (IE header only library)
+target_link_libraries(foobar PRIVATE GSL)
 ```
 
 ## Debugging visualization support
-
 For Visual Studio users, the file [GSL.natvis](./GSL.natvis) in the root directory of the repository can be added to your project if you would like more helpful visualization of GSL types in the Visual Studio debugger than would be offered by default.
 
-## See Also
-
-For information on [Microsoft Gray Systems Lab (GSL)](https://aka.ms/gsl) of applied data management and system research see <https://aka.ms/gsl>.
+If you are using cmake this will be done automatically for you.
+See 'GSL_VS_ADD_NATIVE_VISUALIZERS'

azure-pipelines.yml

@@ -0,0 +1,66 @@
+trigger:
+  - main
+
+pr:
+  autoCancel: true
+
+stages:
+- stage: GCC
+  dependsOn: []
+  jobs:
+  - template: ./pipelines/jobs.yml
+    parameters:
+      compiler: gcc
+      image: ubuntu-20.04
+      compilerVersions: [ 11, 10 ]
+      setupfile: 'setup_gcc.yml'
+
+- stage: Clang
+  dependsOn: []
+  jobs:
+  - template: ./pipelines/jobs.yml
+    parameters:
+      compiler: clang
+      image: ubuntu-20.04
+      compilerVersions: [ 12, 11 ]
+      setupfile: 'setup_clang.yml'
+
+- stage: Xcode
+  dependsOn: []
+  jobs:
+  - template: ./pipelines/jobs.yml
+    parameters:
+      compiler: 'Xcode'
+      image: macOS-11
+      compilerVersions: [ '12.5.1', '13.2.1' ]
+      setupfile: 'setup_apple.yml'
+
+- stage: VS_MSVC
+  dependsOn: []
+  jobs:
+  - template: ./pipelines/jobs.yml
+    parameters:
+      compiler: 'VS2019 (MSVC)'
+      compilerVersions: [ 'default' ]
+      image: windows-2019
+  - template: ./pipelines/jobs.yml
+    parameters:
+      compiler: 'VS2022 (MSVC)'
+      compilerVersions: [ 'default' ]
+      image: windows-2022
+
+- stage: VS_LLVM
+  dependsOn: []
+  jobs:
+  - template: ./pipelines/jobs.yml
+    parameters:
+      compiler: 'VS2019 (LLVM)'
+      compilerVersions: [ 'default' ]
+      image: windows-2019
+      extraCmakeArgs: '-T ClangCL'
+  - template: ./pipelines/jobs.yml
+    parameters:
+      compiler: 'VS2022 (LLVM)'
+      compilerVersions: [ 'default' ]
+      image: windows-2022
+      extraCmakeArgs: '-T ClangCL'

cmake/guidelineSupportLibrary.cmake

@@ -0,0 +1,116 @@
+# 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 (CMAKE_VERSION VERSION_GREATER 3.10 OR CMAKE_VERSION VERSION_EQUAL 3.10)
+    include_guard()
+else()
+    if (DEFINED guideline_support_library_include_guard)
+        return()
+    endif()
+    set(guideline_support_library_include_guard ON)
+endif()
+
+# Necessary for 'write_basic_package_version_file'
+include(CMakePackageConfigHelpers)
+
+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()
+
+# Adding the GSL.natvis files improves the debugging experience for users of this library.
+function(gsl_add_native_visualizer_support)
+    if (CMAKE_VERSION VERSION_GREATER 3.7.8)
+        if (MSVC_IDE)
+            option(GSL_VS_ADD_NATIVE_VISUALIZERS "Configure project to use Visual Studio native visualizers" TRUE)
+        else()
+            set(GSL_VS_ADD_NATIVE_VISUALIZERS FALSE CACHE INTERNAL "Native visualizers are Visual Studio extension" FORCE)
+        endif()
+
+        # add natvis file to the library so it will automatically be loaded into Visual Studio
+        if(GSL_VS_ADD_NATIVE_VISUALIZERS)
+            target_sources(GSL INTERFACE $<BUILD_INTERFACE:${GSL_SOURCE_DIR}/GSL.natvis>)
+        endif()
+    endif()
+endfunction()
+
+function(gsl_install_logic)
+    install(TARGETS GSL EXPORT Microsoft.GSLConfig)
+    install(
+        DIRECTORY include/gsl
+        DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+    )
+    # Make library importable by other projects
+    install(EXPORT Microsoft.GSLConfig NAMESPACE Microsoft.GSL:: DESTINATION ${CMAKE_INSTALL_DATADIR}/cmake/Microsoft.GSL)
+    export(TARGETS GSL NAMESPACE Microsoft.GSL:: FILE Microsoft.GSLConfig.cmake)
+
+    install(FILES ${CMAKE_CURRENT_BINARY_DIR}/Microsoft.GSLConfigVersion.cmake DESTINATION ${CMAKE_INSTALL_DATADIR}/cmake/Microsoft.GSL)
+endfunction()
+
+# Add find_package() versioning support. The version for
+# generated Microsoft.GSLConfigVersion.cmake will be used from
+# last project() command. The version's compatibility is set between all
+# minor versions (as it was in prev. GSL releases).
+function(gsl_create_packaging_file)
+    if(${CMAKE_VERSION} VERSION_LESS "3.14.0")
+        write_basic_package_version_file(
+            ${CMAKE_CURRENT_BINARY_DIR}/Microsoft.GSLConfigVersion.cmake
+            COMPATIBILITY SameMajorVersion
+        )
+    else()
+        write_basic_package_version_file(
+            ${CMAKE_CURRENT_BINARY_DIR}/Microsoft.GSLConfigVersion.cmake
+            COMPATIBILITY SameMajorVersion
+            ARCH_INDEPENDENT
+        )
+    endif()
+endfunction()

docs/upgrade_checklist.md

@@ -1,19 +0,0 @@
-> When bumping the version, you need to update the following files:
-
-1. [ ] [CMakeLists.txt](../CMakeLists.txt) Bump `GSL_VERSION`
-1. [ ] [README.md](../README.md) Bump `GIT_TAG`
-1. [ ] [ios.yml](../.github/workflows/ios.yml) Bump `MACOSX_BUNDLE_BUNDLE_VERSION` and
-`MACOSX_BUNDLE_SHORT_VERSION_STRING`
-
-> After updating, you need to create a new GitHub release:
-
-1. [ ] [Microsoft/GSL - Create Release](https://github.com/microsoft/GSL/releases/new)
-
-Be sure to update the release notes accordingly and properly mention open-source
-contributors.
-
-> After a new release exists, update the `ms-gsl` vcpkg port:
-
-1. [ ] [Microsoft/vcpkg - ms-gsl port](https://github.com/microsoft/vcpkg/tree/master/ports/ms-gsl)
-
-Be sure to monitor the PR that updates the port for any feedback from vcpkg maintainers.

include/CMakeLists.txt

@@ -1,3 +1,4 @@
+
 # Add include folders to the library and targets that consume it
 # the SYSTEM keyword suppresses warnings for users of the library
 #
@@ -6,8 +7,14 @@
 #
 # IE:
 #   #include <gsl/gsl>
-if(PROJECT_IS_TOP_LEVEL)
-    target_include_directories(GSL INTERFACE $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>)
+if(GSL_STANDALONE_PROJECT)
+    target_include_directories(GSL INTERFACE
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
+        $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+    )
 else()
-    target_include_directories(GSL SYSTEM INTERFACE $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>)
+    target_include_directories(GSL SYSTEM INTERFACE
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
+        $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+    )
 endif()

include/gsl/algorithm

@@ -17,8 +17,8 @@
 #ifndef GSL_ALGORITHM_H
 #define GSL_ALGORITHM_H
 
-#include "./assert" // for Expects
-#include "./span"   // for dynamic_extent, span
+#include "assert" // for Expects
+#include "span"   // for dynamic_extent, span
 
 #include <algorithm>   // for copy_n
 #include <cstddef>     // for ptrdiff_t
@@ -48,7 +48,9 @@ void copy(span<SrcElementType, SrcExtent> src, span<DestElementType, DestExtent>
                   "Source range is longer than target range");
 
     Expects(dest.size() >= src.size());
-    GSL_SUPPRESS(stl.1)
+    // clang-format off
+    GSL_SUPPRESS(stl.1) // NO-FORMAT: attribute
+    // clang-format on
     std::copy_n(src.data(), src.size(), dest.data());
 }
 

include/gsl/assert

@@ -14,8 +14,8 @@
 //
 ///////////////////////////////////////////////////////////////////////////////
 
-#ifndef GSL_ASSERT_H
-#define GSL_ASSERT_H
+#ifndef GSL_CONTRACTS_H
+#define GSL_CONTRACTS_H
 
 //
 // Temporary until MSVC STL supports no-exceptions mode.
@@ -46,15 +46,17 @@
 // Hopefully temporary until suppression standardization occurs
 //
 #if defined(__clang__)
-#define GSL_SUPPRESS(x) [[gsl::suppress(#x)]]
-#elif defined(_MSC_VER) && _MSC_VER >= 1950
-// Visual Studio versions after 2022 (_MSC_VER > 1944) support the justification message.
-#define GSL_SUPPRESS(x) [[gsl::suppress(#x)]]
-#elif defined(_MSC_VER) && !defined(__INTEL_COMPILER) && !defined(__NVCC__)
+#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 // defined(__clang__)
+#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)
@@ -93,7 +95,9 @@ namespace details
 
     typedef void(__cdecl* terminate_handler)();
 
-    GSL_SUPPRESS(f.6)
+    // clang-format off
+    GSL_SUPPRESS(f.6) // NO-FORMAT: attribute
+    // clang-format on
     [[noreturn]] inline void __cdecl default_terminate_handler()
     {
         __fastfail(RANGE_CHECKS_FAILURE);
@@ -129,4 +133,4 @@ namespace details
 #pragma clang diagnostic pop
 #endif
 
-#endif // GSL_ASSERT_H
+#endif // GSL_CONTRACTS_H

include/gsl/byte

@@ -17,10 +17,24 @@
 #ifndef GSL_BYTE_H
 #define GSL_BYTE_H
 
-#include "./util" // for GSL_DEPRECATED
+//
+// 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)
@@ -31,15 +45,18 @@
 
 #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(__cpp_lib_byte) && __cpp_lib_byte >= 201603
+#if (defined(_HAS_STD_BYTE) && _HAS_STD_BYTE) ||                                                   \
+    (defined(__cpp_lib_byte) && __cpp_lib_byte >= 201603)
 
 #define GSL_USE_STD_BYTE 1
 
-#else // defined(__cpp_lib_byte) && __cpp_lib_byte >= 201603
+#else // (defined(_HAS_STD_BYTE) && _HAS_STD_BYTE) || (defined(__cpp_lib_byte) && __cpp_lib_byte >=
+      // 201603)
 
 #define GSL_USE_STD_BYTE 0
 
-#endif // defined(__cpp_lib_byte) && __cpp_lib_byte >= 201603
+#endif // (defined(_HAS_STD_BYTE) && _HAS_STD_BYTE) || (defined(__cpp_lib_byte) && __cpp_lib_byte >=
+       // 201603)
 #endif // GSL_USE_STD_BYTE
 
 #else // _MSC_VER
@@ -82,16 +99,7 @@ namespace gsl
 {
 #if GSL_USE_STD_BYTE
 
-namespace impl
-{
-    // impl::byte is used by gsl::as_bytes so our own code does not trigger a deprecation warning as
-    // would be the case when we used gsl::byte. Users of GSL should only use gsl::byte, not
-    // gsl::impl::byte.
-    using byte = std::byte;
-} // namespace impl
-
-using byte GSL_DEPRECATED("Use std::byte instead.") = std::byte;
-
+using std::byte;
 using std::to_integer;
 
 #else // GSL_USE_STD_BYTE
@@ -102,33 +110,25 @@ enum class byte_may_alias byte : unsigned char
 {
 };
 
-namespace impl
-{
-    // impl::byte is used by gsl::as_bytes so our own code does not trigger a deprecation warning as
-    // would be the case when we used gsl::byte. Users of GSL should only use gsl::byte, not
-    // gsl::impl::byte.
-    using byte = gsl::byte;
-} // namespace impl
-
-template <class IntegerType, std::enable_if_t<std::is_integral<IntegerType>::value, bool> = true>
+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, std::enable_if_t<std::is_integral<IntegerType>::value, bool> = true>
+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, std::enable_if_t<std::is_integral<IntegerType>::value, bool> = true>
+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, std::enable_if_t<std::is_integral<IntegerType>::value, bool> = true>
+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);
@@ -166,7 +166,7 @@ constexpr byte operator^(byte l, byte r) noexcept
 
 constexpr byte operator~(byte b) noexcept { return byte(~static_cast<unsigned char>(b)); }
 
-template <class IntegerType, std::enable_if_t<std::is_integral<IntegerType>::value, bool> = true>
+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);
@@ -174,22 +174,34 @@ constexpr IntegerType to_integer(byte b) noexcept
 
 #endif // GSL_USE_STD_BYTE
 
-template <typename T>
-constexpr gsl::impl::byte to_byte(T t) noexcept
+template <bool E, typename T>
+constexpr byte to_byte_impl(T t) noexcept
 {
     static_assert(
-        std::is_same<T, unsigned char>::value,
-        "gsl::to_byte(t) must be provided an unsigned char, otherwise data loss may occur. "
-        "If you are calling to_byte with an integer constant use: gsl::to_byte<t>() version.");
-    return gsl::impl::byte(t);
+        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 gsl::impl::byte to_byte() noexcept
+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<gsl::impl::byte>(I);
+    return static_cast<byte>(I);
 }
 
 } // namespace gsl

include/gsl/dyn_array

@@ -1,439 +0,0 @@
-// -*- C++ -*-
-///////////////////////////////////////////////////////////////////////////////
-//
-// Copyright (c) 2026 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_DYN_ARRAY_H
-#define GSL_DYN_ARRAY_H
-
-#include "./assert"
-#include "./narrow"
-#include "./util"
-
-#include <algorithm>
-#include <iterator>
-#include <memory>
-#include <type_traits>
-
-#if defined(__cpp_lib_ranges) && (__cpp_lib_ranges >= 201911L)
-#include <ranges>
-#endif /* __cpp_lib_ranges >= 201911L */
-
-namespace gsl
-{
-namespace details
-{
-    template <typename T, typename Allocator = std::allocator<T>>
-    class dyn_array_base : public Allocator
-    {
-        using pointer = T*;
-        using size_type = std::size_t;
-
-        template <typename... Args>
-        GSL_CONSTEXPR_SINCE_CPP20 void construct(pointer ptr, Args&&... args)
-        {
-            std::allocator_traits<Allocator>::construct(static_cast<Allocator&>(*this), ptr,
-                                                        std::forward<Args>(args)...);
-        }
-
-        GSL_CONSTEXPR_SINCE_CPP20 void destroy(pointer ptr)
-        {
-            std::allocator_traits<Allocator>::destroy(static_cast<Allocator&>(*this), ptr);
-        }
-
-        GSL_CONSTEXPR_SINCE_CPP20 void destroy_range(pointer first, pointer last)
-        {
-            for (; first != last; ++first) { destroy(first); }
-        }
-
-        GSL_CONSTEXPR_SINCE_CPP20 void rollback_construction(pointer first, pointer last)
-        {
-            destroy_range(first, last);
-            std::allocator_traits<Allocator>::deallocate(static_cast<Allocator&>(*this), _data,
-                                                         _count);
-            _data = nullptr;
-            _count = 0;
-        }
-
-    protected:
-        constexpr auto data() const { return _data; }
-
-        constexpr auto count() const { return _count; }
-
-        GSL_CONSTEXPR_SINCE_CPP20 void resize(size_type count)
-        {
-            // This should only be called when constructing a non-forward iterator.
-            // It neither frees nor copies `_data`.
-            Expects(_data == nullptr && _count == 0);
-            if (count != 0)
-            {
-                _data = std::allocator_traits<Allocator>::allocate(static_cast<Allocator&>(*this),
-                                                                   count);
-                _count = count;
-            }
-        }
-
-        GSL_CONSTEXPR_SINCE_CPP20 void fill(pointer first, size_type count, const T& value)
-        {
-            pointer current = first;
-            try
-            {
-                for (size_type i = 0; i < count; ++i, ++current) { construct(current, value); }
-            } catch (...)
-            {
-                rollback_construction(first, current);
-                throw;
-            }
-        }
-
-        template <typename InputIt>
-        GSL_CONSTEXPR_SINCE_CPP20 void copy(InputIt first, InputIt last, pointer output)
-        {
-            pointer current = output;
-            try
-            {
-                for (; first != last; ++first, ++current) { construct(current, *first); }
-            } catch (...)
-            {
-                rollback_construction(output, current);
-                throw;
-            }
-        }
-
-        GSL_CONSTEXPR_SINCE_CPP20 void default_construct(pointer first, size_type count)
-        {
-            pointer current = first;
-            try
-            {
-                for (size_type i = 0; i < count; ++i, ++current) { construct(current); }
-            } catch (...)
-            {
-                rollback_construction(first, current);
-                throw;
-            }
-        }
-
-    private:
-        pointer _data;
-        size_type _count;
-
-    public:
-        constexpr dyn_array_base(const Allocator& alloc)
-            : Allocator{alloc}, _data{nullptr}, _count{0}
-        {
-            Ensures((_count == 0 && _data == nullptr) || (_count > 0 && _data != nullptr));
-        }
-
-        constexpr dyn_array_base(size_type count, const Allocator& alloc)
-            : Allocator{alloc}
-            , _data{count == 0 ? nullptr
-                               : std::allocator_traits<Allocator>::allocate(
-                                     static_cast<Allocator&>(*this), count)}
-            , _count{count}
-        {
-            Ensures((_count == 0 && _data == nullptr) || (_count > 0 && _data != nullptr));
-        }
-
-        GSL_CONSTEXPR_SINCE_CPP20 ~dyn_array_base()
-        {
-            if (_data)
-            {
-                if (!std::is_trivially_destructible<T>::value)
-                {
-                    destroy_range(_data, _data + _count);
-                }
-                std::allocator_traits<Allocator>::deallocate(static_cast<Allocator&>(*this), _data,
-                                                             _count);
-            }
-        }
-    };
-
-    template <typename T>
-    class dyn_array_iterator
-    {
-        using size_type = std::size_t;
-
-    public:
-        using difference_type = std::ptrdiff_t;
-        using value_type = T;
-        using pointer = T*;
-        using reference = T&;
-        using const_reference = const T&;
-        using iterator_category = std::random_access_iterator_tag;
-
-#if defined(__cpp_lib_ranges) && (__cpp_lib_ranges >= 201911L)
-        constexpr dyn_array_iterator() = default;
-#endif /* __cpp_lib_ranges >= 201911L */
-
-        constexpr dyn_array_iterator(pointer ptr, size_type pos, size_type end_pos)
-            : _ptr{ptr}, _pos{pos}, _end_pos{end_pos}
-        {
-            Ensures((_ptr != nullptr && _end_pos > 0) || (_ptr == nullptr && _end_pos == 0));
-            Ensures(_pos <= _end_pos);
-        }
-
-#if defined(_MSC_VER) && defined(__cpp_lib_ranges) && (__cpp_lib_ranges >= 201911L)
-        constexpr operator pointer() const { return _ptr + gsl::narrow<size_type>(_pos); }
-#endif /* defined(_MSC_VER) && __cpp_lib_ranges >= 201911L */
-
-        constexpr auto operator==(const dyn_array_iterator& other) const
-        {
-            Expects(_ptr == other._ptr);
-            Expects(_end_pos == other._end_pos);
-            return _pos == other._pos;
-        }
-
-        constexpr auto operator!=(const dyn_array_iterator& other) const
-        {
-            return !(*this == other);
-        }
-
-        constexpr auto operator*() const -> reference
-        {
-            Expects(_ptr != nullptr);
-            Expects(_pos < _end_pos);
-            return _ptr[_pos];
-        }
-
-        constexpr auto operator++() -> dyn_array_iterator&
-        {
-            Expects(_pos < _end_pos);
-            ++_pos;
-            return *this;
-        }
-
-        constexpr auto operator++(int)
-        {
-            auto rv = *this;
-            ++(*this);
-            return rv;
-        }
-
-        constexpr auto operator--() -> dyn_array_iterator&
-        {
-            Expects(_pos > 0);
-            --_pos;
-            return *this;
-        }
-
-        constexpr auto operator--(int)
-        {
-            auto rv = *this;
-            --(*this);
-            return rv;
-        }
-
-        constexpr auto operator+=(difference_type diff) -> dyn_array_iterator&
-        {
-            auto new_pos = gsl::narrow<difference_type>(_pos) + diff;
-            Expects(new_pos >= 0);
-            Expects(new_pos <= gsl::narrow<difference_type>(_end_pos));
-            _pos = gsl::narrow<size_type>(new_pos);
-            return *this;
-        }
-
-        constexpr auto operator-=(difference_type diff) -> dyn_array_iterator&
-        {
-            auto new_pos = gsl::narrow<difference_type>(_pos) - diff;
-            Expects(new_pos >= 0);
-            Expects(new_pos <= gsl::narrow<difference_type>(_end_pos));
-            _pos = gsl::narrow<size_type>(new_pos);
-            return *this;
-        }
-
-        constexpr auto operator+(difference_type diff) const
-        {
-            auto new_pos = gsl::narrow<difference_type>(_pos) + diff;
-            return dyn_array_iterator{_ptr, gsl::narrow<size_type>(new_pos), _end_pos};
-        }
-
-        constexpr auto operator-(difference_type diff) const { return *this + (-diff); }
-
-        constexpr auto operator-(const dyn_array_iterator& other) const
-        {
-            Expects(_ptr == other._ptr);
-            Expects(_end_pos == other._end_pos);
-            return gsl::narrow<difference_type>(_pos) - gsl::narrow<difference_type>(other._pos);
-        }
-
-        constexpr auto operator[](size_type pos) -> reference
-        {
-            Expects(_pos + pos < _end_pos);
-            return _ptr[_pos + pos];
-        }
-
-        constexpr auto operator[](size_type pos) const -> const_reference
-        {
-            return const_cast<dyn_array_iterator&>(*this).operator[](pos);
-        }
-
-    private:
-        pointer _ptr{};
-        size_type _pos{};
-        size_type _end_pos{};
-    };
-} // namespace details
-
-template <typename T, typename Allocator = std::allocator<T>>
-class dyn_array : private details::dyn_array_base<T, Allocator>
-{
-    using base = details::dyn_array_base<T, Allocator>;
-    using pointer = T*;
-
-public:
-    using value_type = T;
-    using reference = T&;
-    using const_reference = const T&;
-    using iterator = details::dyn_array_iterator<T>;
-    using const_iterator = details::dyn_array_iterator<const T>;
-    using reverse_iterator = std::reverse_iterator<iterator>;
-    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
-    using difference_type = std::ptrdiff_t;
-    using size_type = std::size_t;
-
-    using allocator_type = Allocator;
-
-    explicit constexpr dyn_array(const Allocator& alloc = {}) : base{alloc} {}
-
-    constexpr dyn_array(size_type count, const T& value, const Allocator& alloc = {})
-        : base{count, alloc}
-    {
-        base::fill(data(), size(), value);
-    }
-
-    template <typename InputIt,
-              std::enable_if_t<details::is_fwd_iterator<InputIt>::value, bool> = true>
-    constexpr dyn_array(InputIt first, InputIt last, const Allocator& alloc = {})
-        : base{gsl::narrow<size_type>(std::distance(first, last)), alloc}
-    {
-        base::copy(first, last, data());
-    }
-
-    template <typename InputIt, std::enable_if_t<!details::is_fwd_iterator<InputIt>::value &&
-                                                     details::is_iterator<InputIt>::value,
-                                                 bool> = true>
-    constexpr dyn_array(InputIt first, InputIt last, const Allocator& alloc = {}) : dyn_array{alloc}
-    {
-        std::vector<T> tmp(first, last);
-        base::resize(tmp.size());
-        base::copy(std::begin(tmp), std::end(tmp), data());
-    }
-
-#if defined(__cpp_lib_containers_ranges) && (__cpp_lib_containers_ranges >= 202202L)
-    template <typename InputRg>
-        requires(std::ranges::input_range<InputRg>)
-    constexpr dyn_array(std::from_range_t, InputRg&& rg, const Allocator& alloc = {})
-        : base{gsl::narrow<size_type>(std::size(rg)), alloc}
-    {
-        base::copy(std::ranges::begin(rg), std::ranges::end(rg), data());
-    }
-#endif /* __cpp_lib_containers_ranges >= 202202L */
-
-    constexpr explicit dyn_array(size_type count, const Allocator& alloc = {}) : base{count, alloc}
-    {
-        base::default_construct(data(), size());
-    }
-
-    constexpr dyn_array(const dyn_array& other, const Allocator& alloc = {})
-        : dyn_array(other.begin(), other.end(), alloc)
-    {}
-
-    constexpr dyn_array(std::initializer_list<T> init, const Allocator& alloc = {})
-        : dyn_array(init.begin(), init.end(), alloc)
-    {}
-
-    constexpr dyn_array(dyn_array&&) = delete;
-    dyn_array& operator=(dyn_array&&) = delete;
-
-    constexpr auto operator==(const dyn_array& other) const
-    {
-        return size() == other.size() && std::equal(begin(), end(), other.begin(), other.end());
-    }
-
-    constexpr auto operator!=(const dyn_array& other) const { return !(*this == other); }
-
-    constexpr auto size() const { return base::count(); }
-
-    constexpr auto empty() const { return size() == 0; }
-
-    constexpr auto max_size() const { return static_cast<size_type>(-1); }
-
-    constexpr auto get_allocator() -> Allocator& { return *this; }
-
-    constexpr auto operator[](size_type pos) -> reference
-    {
-        Expects(pos < size());
-        return data()[pos];
-    }
-
-    constexpr auto operator[](size_type pos) const -> const_reference
-    {
-        return const_cast<dyn_array&>(*this)[pos];
-    }
-
-    constexpr auto data() { return base::data(); }
-    constexpr auto data() const -> const T* { return const_cast<dyn_array&>(*this).data(); }
-
-    constexpr auto begin() { return iterator{data(), 0, size()}; }
-    constexpr auto begin() const { return const_iterator{data(), 0, size()}; }
-    constexpr auto cbegin() const { return begin(); }
-
-    constexpr auto rbegin() { return reverse_iterator{end()}; }
-    constexpr auto rbegin() const { return const_reverse_iterator{end()}; }
-    constexpr auto crbegin() const { return rbegin(); }
-
-#ifdef _MSC_VER
-    constexpr auto _Unchecked_begin() { return data(); }
-    constexpr auto _Unchecked_begin() const -> const T*
-    {
-        return const_cast<dyn_array&>(*this)._Unchecked_begin();
-    }
-#endif /* _MSC_VER */
-
-    constexpr auto end() { return iterator{data(), size(), size()}; }
-    constexpr auto end() const { return const_iterator{data(), size(), size()}; }
-    constexpr auto cend() const { return end(); }
-
-    constexpr auto rend() { return reverse_iterator{begin()}; }
-    constexpr auto rend() const { return const_reverse_iterator{begin()}; }
-    constexpr auto crend() const { return rend(); }
-
-#ifdef _MSC_VER
-    constexpr auto _Unchecked_end() { return data() + size(); }
-    constexpr auto _Unchecked_end() const -> const T*
-    {
-        return const_cast<dyn_array&>(*this)._Unchecked_end();
-    }
-#endif /* _MSC_VER */
-};
-
-#if defined(__cpp_deduction_guides) && (__cpp_deduction_guides >= 201703L)
-
-template <class InputIt,
-          class Alloc = std::allocator<typename std::iterator_traits<InputIt>::value_type>>
-dyn_array(InputIt, InputIt, Alloc = {})
-    -> dyn_array<typename std::iterator_traits<InputIt>::value_type, Alloc>;
-
-#if defined(__cpp_lib_containers_ranges) && (__cpp_lib_containers_ranges >= 202202L)
-template <std::ranges::input_range InputRg,
-          class Alloc = std::allocator<std::ranges::range_value_t<InputRg>>>
-dyn_array(std::from_range_t, InputRg&&, Alloc = {})
-    -> dyn_array<std::ranges::range_value_t<InputRg>, Alloc>;
-#endif /* __cpp_lib_containers_ranges >= 202202L */
-
-#endif /* __cpp_deduction_guides >= 201703L */
-} // namespace gsl
-
-#endif /* defined(GSL_DYN_ARRAY_H) */

include/gsl/gsl

@@ -17,18 +17,16 @@
 #ifndef GSL_GSL_H
 #define GSL_GSL_H
 
-// IWYU pragma: begin_exports
-#include "./algorithm" // copy
-#include "./assert"    // Ensures/Expects
-#include "./byte"      // byte
-#include "./pointers"  // owner, not_null
-#include "./span"      // span
-#include "./util"      // finally()/narrow_cast()...
-#include "./zstring"   // zstring
+#include "algorithm"   // copy
+#include "assert"      // Ensures/Expects
+#include "byte"        // byte
+#include "pointers"    // owner, not_null
+#include "span"        // span
+#include "string_span" // zstring, string_span, zstring_builder...
+#include "util"        // finally()/narrow_cast()...
 
 #ifdef __cpp_exceptions
-#include "./narrow" // narrow()
+#include "narrow" // narrow()
 #endif
-// IWYU pragma: end_exports
 
 #endif // GSL_GSL_H

include/gsl/gsl_algorithm

@@ -0,0 +1,4 @@
+#pragma once
+#pragma message(                                                                                   \
+    "This header will soon be removed. Use <gsl/algorithm> instead of <gsl/gsl_algorithm>")
+#include "algorithm"

include/gsl/gsl_assert

@@ -0,0 +1,3 @@
+#pragma once
+#pragma message("This header will soon be removed. Use <gsl/assert> instead of <gsl/gsl_assert>")
+#include "assert"

include/gsl/gsl_byte

@@ -0,0 +1,3 @@
+#pragma once
+#pragma message("This header will soon be removed. Use <gsl/byte> instead of <gsl/gsl_byte>")
+#include "byte"

include/gsl/gsl_narrow

@@ -0,0 +1,3 @@
+#pragma once
+#pragma message("This header will soon be removed. Use <gsl/narrow> instead of <gsl/gsl_narrow>")
+#include "narrow"

include/gsl/gsl_util

@@ -0,0 +1,3 @@
+#pragma once
+#pragma message("This header will soon be removed. Use <gsl/util> instead of <gsl/gsl_util>")
+#include "util"

include/gsl/narrow

@@ -16,8 +16,8 @@
 
 #ifndef GSL_NARROW_H
 #define GSL_NARROW_H
-#include "./assert"  // for GSL_SUPPRESS
-#include "./util"    // for narrow_cast
+#include "assert"    // for GSL_SUPPRESS
+#include "util"      // for narrow_cast
 #include <exception> // for std::exception
 namespace gsl
 {
@@ -28,47 +28,54 @@ struct narrowing_error : public std::exception
 
 // narrow() : a checked version of narrow_cast() that throws if the cast changed the value
 template <class T, class U, typename std::enable_if<std::is_arithmetic<T>::value>::type* = nullptr>
-GSL_SUPPRESS(type.1)
-    GSL_SUPPRESS(es.46) // The warning suggests that a floating->unsigned conversion can occur
-                        // in the static_cast below, and that gsl::narrow should be used instead.
-                        // Suppress this warning, since gsl::narrow is defined in terms of
-                        // static_cast
-    constexpr T narrow(U 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)
+GSL_SUPPRESS(es.46) // NO-FORMAT: attribute // The warning suggests that a floating->unsigned conversion can occur
+                                            // in the static_cast below, and that gsl::narrow should be used instead.
+                                            // Suppress this warning, since gsl::narrow is defined in terms of
+                                            // static_cast
+    // 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);
 
-    GSL_SUPPRESS(es.103) // don't overflow
-    GSL_SUPPRESS(es.104) // don't underflow
-    GSL_SUPPRESS(p.2)    // don't rely on undefined behavior
-    const T t = narrow_cast<T>(
-        u); // While this is technically undefined behavior in some cases (i.e., if the source value
-            // is of floating-point type and cannot fit into the destination integral type), the
-            // resultant behavior is benign on the platforms that we target (i.e., no hardware trap
-            // representations are hit).
+GSL_SUPPRESS(es.103) // NO-FORMAT: attribute // don't overflow
+GSL_SUPPRESS(es.104) // NO-FORMAT: attribute // don't underflow
+GSL_SUPPRESS(p.2) // NO-FORMAT: attribute // don't rely on undefined behavior
+    const T t = narrow_cast<T>(u); // While this is technically undefined behavior in some cases (i.e., if the source value is of floating-point type
+                                   // and cannot fit into the destination integral type), the resultant behavior is benign on the platforms
+                                   // that we target (i.e., no hardware trap representations are hit).
 
 #if defined(__clang__) || defined(__GNUC__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wfloat-equal"
+    #pragma GCC diagnostic push
+    #pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
-    // Note: NaN will always throw, since NaN != NaN
     if (static_cast<U>(t) != u || (is_different_signedness && ((t < T{}) != (u < U{}))))
     {
         throw narrowing_error{};
     }
 #if defined(__clang__) || defined(__GNUC__)
-#pragma GCC diagnostic pop
+    #pragma GCC diagnostic pop
 #endif
 
     return t;
 }
 
 template <class T, class U, typename std::enable_if<!std::is_arithmetic<T>::value>::type* = nullptr>
-GSL_SUPPRESS(type.1) constexpr T narrow(U 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)
 {
     const T t = narrow_cast<T>(u);
 
-    if (static_cast<U>(t) != u) { throw narrowing_error{}; }
+    if (static_cast<U>(t) != u)
+    {
+        throw narrowing_error{};
+    }
 
     return t;
 }

include/gsl/pointers

@@ -1,4 +1,3 @@
-// -*- C++ -*-
 ///////////////////////////////////////////////////////////////////////////////
 //
 // Copyright (c) 2015 Microsoft Corporation. All rights reserved.
@@ -18,14 +17,13 @@
 #ifndef GSL_POINTERS_H
 #define GSL_POINTERS_H
 
-#include "./assert" // for Ensures, Expects
-#include "./util"   // for GSL_DEPRECATED
+#include "assert" // for Ensures, Expects
 
-#include <cstddef>     // for ptrdiff_t, nullptr_t, size_t
-#include <functional>  // for less, greater
-#include <memory>      // for shared_ptr, unique_ptr, hash
-#include <type_traits> // for enable_if_t, is_convertible, is_assignable
-#include <utility>     // for declval, forward
+#include <algorithm>    // for forward
+#include <cstddef>      // for ptrdiff_t, nullptr_t, 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
@@ -48,41 +46,24 @@ namespace details
         : std::true_type
     {
     };
-
-    // Resolves to the more efficient of `const T` or `const T&`, in the context of returning a
-    // const-qualified value of type T.
-    //
-    // Copied from cppfront's implementation of the CppCoreGuidelines F.16
-    // (https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#rf-in)
-    template <typename T>
-    using value_or_reference_return_t =
-        std::conditional_t<sizeof(T) <= 2 * sizeof(void*) &&
-                               std::is_trivially_copy_constructible<T>::value,
-                           const T, const T&>;
-
 } // namespace details
 
 //
 // GSL.owner: ownership pointers
 //
-template <typename... Ts>
-using shared_ptr GSL_DEPRECATED("Use std::shared_ptr instead") = std::shared_ptr<Ts...>;
-
-template <typename... Ts>
-using unique_ptr GSL_DEPRECATED("Use std::unique_ptr instead") = std::unique_ptr<Ts...>;
+using std::shared_ptr;
+using std::unique_ptr;
 
 //
 // owner
 //
-// `gsl::owner<T>` is designed as a safety mechanism for code that must deal directly with raw
-// pointers that own memory. Ideally such code should be restricted to the implementation of
-// low-level abstractions. `gsl::owner` can also be used as a stepping point in converting legacy
-// code to use more modern RAII constructs, such as smart pointers.
+// 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
 //
-template <class T, std::enable_if_t<std::is_pointer<T>::value, bool> = true>
+template <class T, class = std::enable_if_t<std::is_pointer<T>::value>>
 using owner = T;
 
 //
@@ -105,33 +86,27 @@ class not_null
 public:
     static_assert(details::is_comparable_to_nullptr<T>::value, "T cannot be compared to nullptr.");
 
-    using element_type = T;
-
     template <typename U, typename = std::enable_if_t<std::is_convertible<U, T>::value>>
-    constexpr not_null(U&& u) noexcept(std::is_nothrow_move_constructible<T>::value)
-        : ptr_(std::forward<U>(u))
+    constexpr not_null(U&& u) : ptr_(std::forward<U>(u))
     {
         Expects(ptr_ != nullptr);
     }
 
     template <typename = std::enable_if_t<!std::is_same<std::nullptr_t, T>::value>>
-    constexpr not_null(T u) noexcept(std::is_nothrow_move_constructible<T>::value)
-        : ptr_(std::move(u))
+    constexpr not_null(T u) : ptr_(std::move(u))
     {
         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) noexcept(
-        std::is_nothrow_move_constructible<T>::value)
-        : not_null(other.get())
+    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 details::value_or_reference_return_t<T> get() const
-        noexcept(noexcept(details::value_or_reference_return_t<T>(std::declval<T&>())))
+    constexpr std::conditional_t<std::is_copy_constructible<T>::value, T, const T&> get() const
     {
+        Ensures(ptr_ != nullptr);
         return ptr_;
     }
 
@@ -152,20 +127,10 @@ public:
     not_null& operator-=(std::ptrdiff_t) = delete;
     void operator[](std::ptrdiff_t) const = delete;
 
-    void swap(not_null<T>& other) noexcept { std::swap(ptr_, other.ptr_); }
-
 private:
     T ptr_;
 };
 
-template <typename T, std::enable_if_t<std::is_move_assignable<T>::value &&
-                                           std::is_move_constructible<T>::value,
-                                       bool> = true>
-void swap(not_null<T>& a, not_null<T>& b) noexcept
-{
-    a.swap(b);
-}
-
 template <class T>
 auto make_not_null(T&& t) noexcept
 {
@@ -182,53 +147,51 @@ std::ostream& operator<<(std::ostream& os, const not_null<T>& val)
 #endif // !defined(GSL_NO_IOSTREAMS)
 
 template <class T, class U>
-constexpr auto operator==(const not_null<T>& lhs,
-                          const not_null<U>& rhs) noexcept(noexcept(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>
-constexpr auto operator!=(const not_null<T>& lhs,
-                          const not_null<U>& rhs) noexcept(noexcept(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>
-constexpr auto operator<(const not_null<T>& lhs, const not_null<U>& rhs) noexcept(
-    noexcept(std::less<>{}(lhs.get(), rhs.get()))) -> decltype(std::less<>{}(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 std::less<>{}(lhs.get(), rhs.get());
+    return lhs.get() < rhs.get();
 }
 
 template <class T, class U>
-constexpr auto
-operator<=(const not_null<T>& lhs,
-           const not_null<U>& rhs) noexcept(noexcept(std::less_equal<>{}(lhs.get(), rhs.get())))
-    -> decltype(std::less_equal<>{}(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 std::less_equal<>{}(lhs.get(), rhs.get());
+    return lhs.get() <= rhs.get();
 }
 
 template <class T, class U>
-constexpr auto
-operator>(const not_null<T>& lhs,
-          const not_null<U>& rhs) noexcept(noexcept(std::greater<>{}(lhs.get(), rhs.get())))
-    -> decltype(std::greater<>{}(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 std::greater<>{}(lhs.get(), rhs.get());
+    return lhs.get() > rhs.get();
 }
 
 template <class T, class U>
-constexpr auto
-operator>=(const not_null<T>& lhs,
-           const not_null<U>& rhs) noexcept(noexcept(std::greater_equal<>{}(lhs.get(), rhs.get())))
-    -> decltype(std::greater_equal<>{}(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 std::greater_equal<>{}(lhs.get(), rhs.get());
+    return lhs.get() >= rhs.get();
 }
 
 // more unwanted operators
@@ -241,30 +204,14 @@ not_null<T> operator+(const not_null<T>&, std::ptrdiff_t) = delete;
 template <class T>
 not_null<T> operator+(std::ptrdiff_t, const not_null<T>&) = delete;
 
-// T is conceptually a pointer so we don't have to worry about it being a reference and violating
-// std::hash requirements
-template <class T, class U = typename T::element_type,
-          bool = std::is_default_constructible<std::hash<U>>::value>
-struct not_null_hash
-{
-    std::size_t operator()(const T& value) const noexcept { return std::hash<U>{}(value.get()); }
-};
-
-template <class T, class U>
-struct not_null_hash<T, U, false>
-{
-    not_null_hash() = delete;
-    not_null_hash(const not_null_hash&) = delete;
-    not_null_hash& operator=(const not_null_hash&) = delete;
-};
-
 } // namespace gsl
 
 namespace std
 {
 template <class T>
-struct hash<gsl::not_null<T>> : gsl::not_null_hash<gsl::not_null<T>>
+struct hash<gsl::not_null<T>>
 {
+    std::size_t operator()(const gsl::not_null<T>& value) const { return hash<T>{}(value.get()); }
 };
 
 } // namespace std
@@ -294,32 +241,22 @@ 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) noexcept(std::is_nothrow_move_constructible<T>::value)
-        : 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) noexcept(std::is_nothrow_move_constructible<T>::value)
-        : not_null<T>(std::move(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) noexcept(
-        std::is_nothrow_move_constructible<T>::value)
-        : 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) noexcept(
-        std::is_nothrow_move_constructible<T>::value)
-        : not_null<T>(other)
+    constexpr strict_not_null(const strict_not_null<U>& other) : not_null<T>(other)
     {}
 
-    // To avoid invalidating the "not null" invariant, the contained pointer is actually copied
-    // instead of moved. If it is a custom pointer, its constructor could in theory throw
-    // exceptions.
-    strict_not_null(strict_not_null&& other) noexcept(
-        std::is_nothrow_copy_constructible<T>::value) = default;
+    strict_not_null(strict_not_null&& other) = default;
     strict_not_null(const strict_not_null& other) = default;
     strict_not_null& operator=(const strict_not_null& other) = default;
     strict_not_null& operator=(const not_null<T>& other)
@@ -358,7 +295,7 @@ 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 >= 201703L)
+#if (defined(__cpp_deduction_guides) && (__cpp_deduction_guides >= 201611L))
 
 // deduction guides to prevent the ctad-maybe-unsupported warning
 template <class T>
@@ -366,15 +303,19 @@ 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 >= 201703L)
+#endif // ( defined(__cpp_deduction_guides) && (__cpp_deduction_guides >= 201611L) )
 
 } // namespace gsl
 
 namespace std
 {
 template <class T>
-struct hash<gsl::strict_not_null<T>> : gsl::not_null_hash<gsl::strict_not_null<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());
+    }
 };
 
 } // namespace std

include/gsl/span

@@ -1,4 +1,3 @@
-// -*- C++ -*-
 ///////////////////////////////////////////////////////////////////////////////
 //
 // Copyright (c) 2015 Microsoft Corporation. All rights reserved.
@@ -18,10 +17,10 @@
 #ifndef GSL_SPAN_H
 #define GSL_SPAN_H
 
-#include "./assert"   // for Expects
-#include "./byte"     // for gsl::impl::byte
-#include "./span_ext" // for span specialization of gsl::at and other span-related extensions
-#include "./util"     // for narrow_cast
+#include "assert"   // for Expects
+#include "byte"     // for byte
+#include "span_ext" // for span specialization of gsl::at and other span-related extensions
+#include "util"     // for narrow_cast
 
 #include <array>       // for array
 #include <cstddef>     // for ptrdiff_t, size_t, nullptr_t
@@ -43,7 +42,7 @@
 #pragma warning(disable : 4702) // unreachable code
 
 // Turn MSVC /analyze rules that generate too much noise. TODO: fix in the tool.
-#pragma warning(disable : 26495) // uninitialized member when constructor calls constructor
+#pragma warning(disable : 26495) // uninitalized member when constructor calls constructor
 #pragma warning(disable : 26446) // parser bug does not allow attributes on some templates
 
 #endif // _MSC_VER
@@ -54,7 +53,7 @@
 #define GSL_USE_STATIC_CONSTEXPR_WORKAROUND
 #endif // !(defined(__cplusplus) && (__cplusplus >= 201703L))
 
-// GCC 7 does not like the signed unsigned mismatch (size_t ptrdiff_t)
+// GCC 7 does not like the signed unsigned missmatch (size_t ptrdiff_t)
 // While there is a conversion from signed to unsigned, it happens at
 // compiletime, so the compiler wouldn't have to warn indiscriminately, but
 // could check if the source value actually doesn't fit into the target type
@@ -64,14 +63,6 @@
 #pragma GCC diagnostic ignored "-Wsign-conversion"
 #endif
 
-// Turn off clang unsafe buffer warnings as all accessed are guarded by runtime checks
-#if defined(__clang__)
-#if __has_warning("-Wunsafe-buffer-usage")
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wunsafe-buffer-usage"
-#endif // __has_warning("-Wunsafe-buffer-usage")
-#endif // defined(__clang__)
-
 namespace gsl
 {
 
@@ -135,15 +126,12 @@ namespace details
 
 #ifdef _MSC_VER
         using _Unchecked_type = pointer;
-        using _Prevent_inheriting_unwrap = span_iterator;
 #endif // _MSC_VER
         constexpr span_iterator() = default;
 
         constexpr span_iterator(pointer begin, pointer end, pointer current)
             : begin_(begin), end_(end), current_(current)
-        {
-            Expects(begin_ <= current_ && current <= end_);
-        }
+        {}
 
         constexpr operator span_iterator<const Type>() const noexcept
         {
@@ -152,19 +140,24 @@ namespace details
 
         constexpr reference operator*() const noexcept
         {
-            Expects(current_ != end_);
+            Expects(begin_ && end_);
+            Expects(begin_ <= current_ && current_ < end_);
             return *current_;
         }
 
         constexpr pointer operator->() const noexcept
         {
-            Expects(current_ != end_);
+            Expects(begin_ && end_);
+            Expects(begin_ <= current_ && current_ < end_);
             return current_;
         }
         constexpr span_iterator& operator++() noexcept
         {
-            Expects(current_ != end_);
-            GSL_SUPPRESS(bounds.1)
+            Expects(begin_ && current_ && end_);
+            Expects(current_ < end_);
+            // clang-format off
+            GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
+            // clang-format on
             ++current_;
             return *this;
         }
@@ -178,7 +171,8 @@ namespace details
 
         constexpr span_iterator& operator--() noexcept
         {
-            Expects(begin_ != current_);
+            Expects(begin_ && end_);
+            Expects(begin_ < current_);
             --current_;
             return *this;
         }
@@ -195,7 +189,9 @@ namespace details
             if (n != 0) Expects(begin_ && current_ && end_);
             if (n > 0) Expects(end_ - current_ >= n);
             if (n < 0) Expects(current_ - begin_ >= -n);
-            GSL_SUPPRESS(bounds.1)
+            // clang-format off
+            GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
+            // clang-format on
             current_ += n;
             return *this;
         }
@@ -218,7 +214,6 @@ namespace details
             if (n != 0) Expects(begin_ && current_ && end_);
             if (n > 0) Expects(current_ - begin_ >= n);
             if (n < 0) Expects(end_ - current_ >= -n);
-            GSL_SUPPRESS(bounds.1)
             current_ -= n;
             return *this;
         }
@@ -312,7 +307,9 @@ namespace details
             if (n < 0) Expects(current_ - begin_ >= -n);
         }
 
-        GSL_SUPPRESS(bounds.1)
+        // clang-format off
+        GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
+        // clang-format on
         constexpr pointer _Unwrapped() const noexcept
         { // after seeking *this to a high water mark, or using one of the
             // _Verify_xxx functions above, unwrap this span_iterator to a raw
@@ -327,7 +324,9 @@ namespace details
 #else
         static constexpr bool _Unwrap_when_unverified = false;
 #endif
-        GSL_SUPPRESS(con.3) // TODO: false positive
+        // clang-format off
+        GSL_SUPPRESS(con.3) // NO-FORMAT: attribute // TODO: false positive
+        // clang-format on
         constexpr void _Seek_to(const pointer p) noexcept
         { // adjust the position of *this to previously verified location p
             // after _Unwrapped
@@ -342,26 +341,20 @@ namespace details
         template <typename Ptr>
         friend struct std::pointer_traits;
     };
-} // namespace details
-} // namespace gsl
+}} // namespace gsl::details
 
-namespace std
-{
 template <class Type>
-struct pointer_traits<::gsl::details::span_iterator<Type>>
-{
-    using pointer = ::gsl::details::span_iterator<Type>;
-    using element_type = Type;
+struct std::pointer_traits<::gsl::details::span_iterator<Type>> {
+    using pointer         = ::gsl::details::span_iterator<Type>;
+    using element_type    = Type;
     using difference_type = ptrdiff_t;
 
-    static constexpr element_type* to_address(const pointer i) noexcept { return i.current_; }
+    static constexpr element_type* to_address(const pointer i) noexcept {
+        return i.current_;
+    }
 };
-} // namespace std
 
-namespace gsl
-{
-namespace details
-{
+namespace gsl { namespace details {
     template <std::size_t Ext>
     class extent_type
     {
@@ -579,28 +572,27 @@ public:
     template <std::size_t Count>
     constexpr span<element_type, Count> first() const noexcept
     {
-        static_assert(Extent == dynamic_extent || Count <= Extent,
-                      "first() cannot extract more elements from a span than it contains.");
         Expects(Count <= size());
         return span<element_type, Count>{data(), Count};
     }
 
     template <std::size_t Count>
-    GSL_SUPPRESS(bounds.1) constexpr span<element_type, Count> last() const noexcept
+    // clang-format off
+    GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
+        // clang-format on
+        constexpr span<element_type, Count> last() const noexcept
     {
-        static_assert(Extent == dynamic_extent || Count <= Extent,
-                      "last() cannot extract more elements from a span than it contains.");
         Expects(Count <= size());
         return span<element_type, Count>{data() + (size() - Count), Count};
     }
 
     template <std::size_t Offset, std::size_t Count = dynamic_extent>
-    GSL_SUPPRESS(bounds.1) constexpr auto subspan() const noexcept ->
+    // clang-format off
+    GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
+        // clang-format on
+        constexpr auto subspan() const noexcept ->
         typename details::calculate_subspan_type<ElementType, Extent, Offset, Count>::type
     {
-        static_assert(Extent == dynamic_extent || (Extent >= Offset && (Count == dynamic_extent ||
-                                                                        Count <= Extent - Offset)),
-                      "subspan() cannot extract more elements from a span than it contains.");
         Expects((size() >= Offset) && (Count == dynamic_extent || (Count <= size() - Offset)));
         using type =
             typename details::calculate_subspan_type<ElementType, Extent, Offset, Count>::type;
@@ -628,12 +620,18 @@ public:
     // [span.obs], span observers
     constexpr size_type size() const noexcept { return storage_.size(); }
 
-    constexpr size_type size_bytes() const noexcept { return size() * sizeof(element_type); }
+    constexpr size_type size_bytes() const noexcept
+    {
+        Expects(size() < dynamic_extent / sizeof(element_type));
+        return size() * sizeof(element_type);
+    }
 
     constexpr bool empty() const noexcept { return size() == 0; }
 
     // [span.elem], span element access
-    GSL_SUPPRESS(bounds.1)
+    // clang-format off
+    GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
+    // clang-format on
     constexpr reference operator[](size_type idx) const noexcept
     {
         Expects(idx < size());
@@ -658,14 +656,18 @@ public:
     constexpr iterator begin() const noexcept
     {
         const auto data = storage_.data();
-        GSL_SUPPRESS(bounds.1)
+        // clang-format off
+        GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
+        // clang-format on
         return {data, data + size(), data};
     }
 
     constexpr iterator end() const noexcept
     {
         const auto data = storage_.data();
-        GSL_SUPPRESS(bounds.1)
+        // clang-format off
+        GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
+        // clang-format on
         const auto endData = data + storage_.size();
         return {data, endData, endData};
     }
@@ -678,7 +680,9 @@ public:
     constexpr pointer _Unchecked_begin() const noexcept { return data(); }
     constexpr pointer _Unchecked_end() const noexcept
     {
-        GSL_SUPPRESS(bounds.1)
+        // clang-format off
+        GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
+        // clang-format on
         return data() + size();
     }
 #endif // _MSC_VER
@@ -735,7 +739,9 @@ private:
         return tmp.subspan(offset, count);
     }
 
-    GSL_SUPPRESS(bounds.1)
+    // clang-format off
+    GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
+    // clang-format on
     constexpr span<element_type, dynamic_extent>
     make_subspan(size_type offset, size_type count, subspan_selector<dynamic_extent>) const noexcept
     {
@@ -748,7 +754,7 @@ private:
     }
 };
 
-#if defined(__cpp_deduction_guides) && (__cpp_deduction_guides >= 201703L)
+#if (defined(__cpp_deduction_guides) && (__cpp_deduction_guides >= 201611L))
 
 // Deduction Guides
 template <class Type, std::size_t Extent>
@@ -768,20 +774,11 @@ template <class Container,
           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 >= 201703L)
+#endif // ( defined(__cpp_deduction_guides) && (__cpp_deduction_guides >= 201611L) )
 
 #if defined(GSL_USE_STATIC_CONSTEXPR_WORKAROUND)
-#if defined(__clang__) && defined(_MSC_VER) && defined(__cplusplus) && (__cplusplus < 201703L)
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored                                                                   \
-    "-Wdeprecated" // Bug in clang-cl.exe which raises a C++17 -Wdeprecated warning about this
-                   // static constexpr workaround in C++14 mode.
-#endif // defined(__clang__) && defined(_MSC_VER) && defined(__cplusplus) && (__cplusplus < 201703L)
 template <class ElementType, std::size_t Extent>
 constexpr const typename span<ElementType, Extent>::size_type span<ElementType, Extent>::extent;
-#if defined(__clang__) && defined(_MSC_VER) && defined(__cplusplus) && (__cplusplus < 201703L)
-#pragma clang diagnostic pop
-#endif // defined(__clang__) && defined(_MSC_VER) && defined(__cplusplus) && (__cplusplus < 201703L)
 #endif
 
 namespace details
@@ -807,25 +804,28 @@ namespace details
 
 // [span.objectrep], views of object representation
 template <class ElementType, std::size_t Extent>
-span<const gsl::impl::byte, details::calculate_byte_size<ElementType, Extent>::value>
+span<const byte, details::calculate_byte_size<ElementType, Extent>::value>
 as_bytes(span<ElementType, Extent> s) noexcept
 {
-    using type =
-        span<const gsl::impl::byte, details::calculate_byte_size<ElementType, Extent>::value>;
+    using type = span<const byte, details::calculate_byte_size<ElementType, Extent>::value>;
 
-    GSL_SUPPRESS(type.1)
-    return type{reinterpret_cast<const gsl::impl::byte*>(s.data()), s.size_bytes()};
+    // clang-format off
+    GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
+    // clang-format on
+    return type{reinterpret_cast<const byte*>(s.data()), s.size_bytes()};
 }
 
 template <class ElementType, std::size_t Extent,
           std::enable_if_t<!std::is_const<ElementType>::value, int> = 0>
-span<gsl::impl::byte, details::calculate_byte_size<ElementType, Extent>::value>
+span<byte, details::calculate_byte_size<ElementType, Extent>::value>
 as_writable_bytes(span<ElementType, Extent> s) noexcept
 {
-    using type = span<gsl::impl::byte, details::calculate_byte_size<ElementType, Extent>::value>;
+    using type = span<byte, details::calculate_byte_size<ElementType, Extent>::value>;
 
-    GSL_SUPPRESS(type.1)
-    return type{reinterpret_cast<gsl::impl::byte*>(s.data()), s.size_bytes()};
+    // clang-format off
+    GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
+    // clang-format on
+    return type{reinterpret_cast<byte*>(s.data()), s.size_bytes()};
 }
 
 } // namespace gsl
@@ -839,10 +839,4 @@ as_writable_bytes(span<ElementType, Extent> s) noexcept
 #pragma GCC diagnostic pop
 #endif // __GNUC__ > 6
 
-#if defined(__clang__)
-#if __has_warning("-Wunsafe-buffer-usage")
-#pragma clang diagnostic pop
-#endif // __has_warning("-Wunsafe-buffer-usage")
-#endif // defined(__clang__)
-
 #endif // GSL_SPAN_H

include/gsl/span_ext

@@ -27,8 +27,8 @@
 //
 ///////////////////////////////////////////////////////////////////////////////
 
-#include "./assert" // GSL_KERNEL_MODE
-#include "./util"   // for narrow_cast, narrow
+#include "assert" // GSL_KERNEL_MODE
+#include "util"   // for narrow_cast, narrow
 
 #include <cstddef> // for ptrdiff_t, size_t
 #include <utility>
@@ -123,14 +123,12 @@ constexpr span<const typename Container::value_type> make_span(const Container&
 }
 
 template <class Ptr>
-GSL_DEPRECATED("This function is deprecated. See GSL issue #1092.")
 constexpr span<typename Ptr::element_type> make_span(Ptr& cont, std::size_t count)
 {
     return span<typename Ptr::element_type>(cont, count);
 }
 
 template <class Ptr>
-GSL_DEPRECATED("This function is deprecated. See GSL issue #1092.")
 constexpr span<typename Ptr::element_type> make_span(Ptr& cont)
 {
     return span<typename Ptr::element_type>(cont);
@@ -149,7 +147,7 @@ constexpr ElementType& at(span<ElementType, Extent> s, index i)
 template <class ElementType, std::size_t Extent>
 constexpr std::ptrdiff_t ssize(const span<ElementType, Extent>& s) noexcept
 {
-    return gsl::narrow_cast<std::ptrdiff_t>(s.size());
+    return static_cast<std::ptrdiff_t>(s.size());
 }
 
 // [span.iter] Free functions for begin/end functions

include/gsl/string_span

@@ -0,0 +1,759 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// 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_STRING_SPAN_H
+#define GSL_STRING_SPAN_H
+
+#include "assert"   // for Ensures, Expects
+#include "span_ext" // for operator!=, operator==, dynamic_extent
+#include "util"     // for narrow_cast
+
+#include <algorithm> // for equal, lexicographical_compare
+#include <array>     // for array
+#include <cstddef>   // for size_t, nullptr_t
+#include <cstdint>   // for PTRDIFF_MAX
+#include <cstring>
+#include <string>      // for basic_string, allocator, char_traits
+#include <type_traits> // for declval, is_convertible, enable_if_t, add_...
+
+#if defined(_MSC_VER) && !defined(__clang__)
+#pragma warning(push)
+
+// Turn MSVC /analyze rules that generate too much noise. TODO: fix in the tool.
+#pragma warning(disable : 26446) // TODO: bug in parser - attributes and templates
+#pragma warning(disable : 26481) // TODO: suppress does not work inside templates sometimes
+#pragma warning(disable : 4996)  // use of functions & classes marked [[deprecated]]
+#endif                           // _MSC_VER
+
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+
+namespace gsl
+{
+//
+// czstring and wzstring
+//
+// These are "tag" typedefs for C-style strings (i.e. null-terminated character arrays)
+// that allow static analysis to help find bugs.
+//
+// There are no additional features/semantics that we can find a way to add inside the
+// type system for these types that will not either incur significant runtime costs or
+// (sometimes needlessly) break existing programs when introduced.
+//
+
+template <typename CharT, std::size_t Extent = dynamic_extent>
+using basic_zstring = CharT*;
+
+using czstring = basic_zstring<const char, dynamic_extent>;
+
+using cwzstring = basic_zstring<const wchar_t, dynamic_extent>;
+
+using cu16zstring = basic_zstring<const char16_t, dynamic_extent>;
+
+using cu32zstring = basic_zstring<const char32_t, dynamic_extent>;
+
+using zstring = basic_zstring<char, dynamic_extent>;
+
+using wzstring = basic_zstring<wchar_t, dynamic_extent>;
+
+using u16zstring = basic_zstring<char16_t, dynamic_extent>;
+
+using u32zstring = basic_zstring<char32_t, dynamic_extent>;
+
+namespace details
+{
+    template <class CharT>
+    [[deprecated("string_span was removed from the C++ Core Guidelines. For more information, see "
+                 "isocpp/CppCoreGuidelines PR#1680")]] constexpr std::size_t
+    string_length(const CharT* str, std::size_t n)
+    {
+        if (str == nullptr || n == dynamic_extent) return 0;
+
+        const span<const CharT> str_span{str, n};
+
+        std::size_t len = 0;
+        while (len < n && str_span[len]) len++;
+
+        return len;
+    }
+} // namespace details
+
+//
+// ensure_sentinel()
+//
+// Provides a way to obtain an span from a contiguous sequence
+// that ends with a (non-inclusive) sentinel value.
+//
+// Will fail-fast if sentinel cannot be found before max elements are examined.
+//
+template <typename T, const T Sentinel>
+[[deprecated("string_span was removed from the C++ Core Guidelines. For more information, see "
+             "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);
+
+    // clang-format off
+    GSL_SUPPRESS(f.23) // TODO: false positive // TODO: suppress does not work
+    // clang-format on
+    auto cur = seq;
+    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);
+    return {seq, static_cast<std::size_t>(cur - seq)};
+}
+
+//
+// ensure_z - creates a span for a zero terminated strings. The span will not contain the zero
+// termination. Will fail fast if a null-terminator cannot be found before the limit of size_type.
+//
+template <typename CharT>
+[[deprecated("string_span was removed from the C++ Core Guidelines. For more information, see "
+             "isocpp/CppCoreGuidelines PR#1680")]] constexpr span<CharT, dynamic_extent>
+ensure_z(CharT* const& sz, std::size_t max = static_cast<std::size_t>(-1))
+{
+    return ensure_sentinel<CharT, CharT(0)>(sz, max);
+}
+
+template <typename CharT, std::size_t N>
+constexpr span<CharT, dynamic_extent> ensure_z(CharT (&sz)[N])
+{
+    return ensure_z(&sz[0], N);
+}
+
+template <class Cont>
+[[deprecated(
+    "string_span was removed from the C++ Core Guidelines. For more information, see "
+    "isocpp/CppCoreGuidelines PR#1680")]] constexpr span<typename std::
+                                                             remove_pointer<
+                                                                 typename Cont::pointer>::type,
+                                                         dynamic_extent>
+ensure_z(Cont& cont)
+{
+    return ensure_z(cont.data(), cont.size());
+}
+
+template <typename CharT, std::size_t>
+class [[deprecated("string_span was removed from the C++ Core Guidelines. For more information, "
+                   "see isocpp/CppCoreGuidelines PR#1680")]] basic_string_span;
+
+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{};
+
+    template <typename CharT, std::size_t Extent>
+    struct [[deprecated(
+        "string_span was removed from the C++ Core Guidelines. For more information, see "
+        "isocpp/CppCoreGuidelines PR#1680")]] is_basic_string_span_oracle<basic_string_span<CharT,
+                                                                                            Extent>>
+        : std::true_type{};
+
+    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
+        : is_basic_string_span_oracle<std::remove_cv_t<T>>{};
+} // namespace details
+
+//
+// string_span and relatives
+//
+template <typename CharT, std::size_t Extent = dynamic_extent>
+class [[deprecated("string_span was removed from the C++ Core Guidelines. For more information, "
+                   "see isocpp/CppCoreGuidelines PR#1680")]] basic_string_span
+{
+public:
+    using element_type = CharT;
+    using value_type = std::remove_cv_t<element_type>;
+    using pointer = std::add_pointer_t<element_type>;
+    using reference = std::add_lvalue_reference_t<element_type>;
+    using const_reference = std::add_lvalue_reference_t<std::add_const_t<element_type>>;
+    using impl_type = span<element_type, Extent>;
+
+    using size_type = typename impl_type::size_type;
+    using iterator = typename impl_type::iterator;
+    using reverse_iterator = typename impl_type::reverse_iterator;
+
+    // default (empty)
+    constexpr basic_string_span() noexcept = default;
+
+    // copy
+    constexpr basic_string_span(const basic_string_span& other) noexcept = default;
+
+    // assign
+    constexpr basic_string_span& operator=(const basic_string_span& other) noexcept = default;
+
+    constexpr basic_string_span(pointer ptr, size_type length) : span_(ptr, length) {}
+    constexpr basic_string_span(pointer firstElem, pointer lastElem) : span_(firstElem, lastElem) {}
+
+    // From static arrays - if 0-terminated, remove 0 from the view
+    // All other containers allow 0s within the length, so we do not remove them
+    template <std::size_t N>
+    constexpr basic_string_span(element_type(&arr)[N]) : span_(remove_z(arr))
+    {}
+
+    template <std::size_t N, class ArrayElementType = std::remove_const_t<element_type>>
+    constexpr basic_string_span(std::array<ArrayElementType, N> & arr) noexcept : span_(arr)
+    {}
+
+    template <std::size_t N, class ArrayElementType = std::remove_const_t<element_type>>
+    constexpr basic_string_span(const std::array<ArrayElementType, N>& arr) noexcept : span_(arr)
+    {}
+
+    // Container signature should work for basic_string after C++17 version exists
+    template <class Traits, class Allocator>
+    // GSL_SUPPRESS(bounds.4) // TODO: parser bug
+    constexpr basic_string_span(std::basic_string<element_type, Traits, Allocator> & str)
+        : span_(&str[0], str.length())
+    {}
+
+    template <class Traits, class Allocator>
+    constexpr basic_string_span(const std::basic_string<element_type, Traits, Allocator>& str)
+        : span_(&str[0], str.length())
+    {}
+
+    // from containers. Containers must have a pointer type and data() function signatures
+    template <class Container,
+              class = std::enable_if_t<
+                  !details::is_basic_string_span<Container>::value &&
+                  std::is_convertible<typename Container::pointer, pointer>::value &&
+                  std::is_convertible<typename Container::pointer,
+                                      decltype(std::declval<Container>().data())>::value>>
+    constexpr basic_string_span(Container & cont) : span_(cont)
+    {}
+
+    template <class Container,
+              class = std::enable_if_t<
+                  !details::is_basic_string_span<Container>::value &&
+                  std::is_convertible<typename Container::pointer, pointer>::value &&
+                  std::is_convertible<typename Container::pointer,
+                                      decltype(std::declval<Container>().data())>::value>>
+    constexpr basic_string_span(const Container& cont) : span_(cont)
+    {}
+
+    // from string_span
+    template <
+        class OtherValueType, std::size_t OtherExtent,
+        class = std::enable_if_t<std::is_convertible<
+            typename basic_string_span<OtherValueType, OtherExtent>::impl_type, impl_type>::value>>
+    constexpr basic_string_span(basic_string_span<OtherValueType, OtherExtent> other)
+        : span_(other.data(), other.length())
+    {}
+
+    template <size_type Count>
+    constexpr basic_string_span<element_type, Count> first() const
+    {
+        return {span_.template first<Count>()};
+    }
+
+    constexpr basic_string_span<element_type, dynamic_extent> first(size_type count) const
+    {
+        return {span_.first(count)};
+    }
+
+    template <size_type Count>
+    constexpr basic_string_span<element_type, Count> last() const
+    {
+        return {span_.template last<Count>()};
+    }
+
+    constexpr basic_string_span<element_type, dynamic_extent> last(size_type count) const
+    {
+        return {span_.last(count)};
+    }
+
+    template <size_type Offset, size_type Count>
+    constexpr basic_string_span<element_type, Count> subspan() const
+    {
+        return {span_.template subspan<Offset, Count>()};
+    }
+
+    constexpr basic_string_span<element_type, dynamic_extent> subspan(
+        size_type offset, size_type count = dynamic_extent) const
+    {
+        return {span_.subspan(offset, count)};
+    }
+
+    constexpr reference operator[](size_type idx) const { return span_[idx]; }
+    constexpr reference operator()(size_type idx) const { return span_[idx]; }
+
+    constexpr pointer data() const { return span_.data(); }
+
+    constexpr size_type length() const noexcept { return span_.size(); }
+    constexpr size_type size() const noexcept { return span_.size(); }
+    constexpr size_type size_bytes() const noexcept { return span_.size_bytes(); }
+    constexpr size_type length_bytes() const noexcept { return span_.length_bytes(); }
+    constexpr bool empty() const noexcept { return size() == 0; }
+
+    constexpr iterator begin() const noexcept { return span_.begin(); }
+    constexpr iterator end() const noexcept { return span_.end(); }
+
+    constexpr reverse_iterator rbegin() const noexcept { return span_.rbegin(); }
+    constexpr reverse_iterator rend() const noexcept { return span_.rend(); }
+
+private:
+    static constexpr impl_type remove_z(pointer const& sz, std::size_t max)
+    {
+        return impl_type(sz, details::string_length(sz, max));
+    }
+
+    template <std::size_t N>
+    static constexpr impl_type remove_z(element_type(&sz)[N])
+    {
+        return remove_z(&sz[0], N);
+    }
+
+    impl_type span_;
+};
+
+template <std::size_t Extent = dynamic_extent>
+using string_span [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                               "information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_string_span<char, Extent>;
+
+template <std::size_t Extent = dynamic_extent>
+using cstring_span [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                                "information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_string_span<const char, Extent>;
+
+template <std::size_t Extent = dynamic_extent>
+using wstring_span [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                                "information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_string_span<wchar_t, Extent>;
+
+template <std::size_t Extent = dynamic_extent>
+using cwstring_span [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                                 "information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_string_span<const wchar_t, Extent>;
+
+template <std::size_t Extent = dynamic_extent>
+using u16string_span [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                                  "information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_string_span<char16_t, Extent>;
+
+template <std::size_t Extent = dynamic_extent>
+using cu16string_span [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                                   "information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_string_span<const char16_t, Extent>;
+
+template <std::size_t Extent = dynamic_extent>
+using u32string_span [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                                  "information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_string_span<char32_t, Extent>;
+
+template <std::size_t Extent = dynamic_extent>
+using cu32string_span [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                                   "information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_string_span<const char32_t, Extent>;
+
+//
+// to_string() allow (explicit) conversions from string_span to string
+//
+
+template <typename CharT, std::size_t Extent>
+constexpr std::basic_string<typename std::remove_const<CharT>::type>
+to_string(basic_string_span<CharT, Extent> view)
+{
+    return {view.data(), narrow_cast<std::size_t>(view.length())};
+}
+
+template <typename CharT, typename Traits = typename std::char_traits<CharT>,
+          typename Allocator = std::allocator<CharT>, typename gCharT, std::size_t Extent>
+constexpr std::basic_string<CharT, Traits, Allocator>
+to_basic_string(basic_string_span<gCharT, Extent> view)
+{
+    return {view.data(), narrow_cast<std::size_t>(view.length())};
+}
+
+template <class ElementType, std::size_t Extent>
+constexpr basic_string_span<const byte, details::calculate_byte_size<ElementType, Extent>::value>
+as_bytes(basic_string_span<ElementType, Extent> s) noexcept
+{
+    // clang-format off
+    GSL_SUPPRESS(type.1)
+    // clang-format on
+    return {reinterpret_cast<const byte*>(s.data()), s.size_bytes()};
+}
+
+template <class ElementType, std::size_t Extent,
+          class = std::enable_if_t<!std::is_const<ElementType>::value>>
+constexpr basic_string_span<byte, details::calculate_byte_size<ElementType, Extent>::value>
+as_writable_bytes(basic_string_span<ElementType, Extent> s) noexcept
+{
+    // clang-format off
+    GSL_SUPPRESS(type.1)
+    // clang-format on
+    return {reinterpret_cast<byte*>(s.data()), s.size_bytes()};
+}
+
+// zero-terminated string span, used to convert
+// zero-terminated spans to legacy strings
+template <typename CharT, std::size_t Extent = dynamic_extent>
+class [[deprecated("string_span was removed from the C++ Core Guidelines. For more information, "
+                   "see isocpp/CppCoreGuidelines PR#1680")]] basic_zstring_span
+{
+public:
+    using value_type = CharT;
+    using const_value_type = std::add_const_t<CharT>;
+
+    using pointer = std::add_pointer_t<value_type>;
+    using const_pointer = std::add_pointer_t<const_value_type>;
+
+    using zstring_type = basic_zstring<value_type, Extent>;
+    using const_zstring_type = basic_zstring<const_value_type, Extent>;
+
+    using impl_type = span<value_type, Extent>;
+    using string_span_type = basic_string_span<value_type, Extent>;
+
+    constexpr basic_zstring_span(impl_type s) : span_(s)
+    {
+        // expects a zero-terminated span
+        Expects(s.size() > 0);
+        Expects(s[s.size() - 1] == value_type{});
+    }
+
+    // copy
+    constexpr basic_zstring_span(const basic_zstring_span& other) = default;
+
+    // move
+    constexpr basic_zstring_span(basic_zstring_span && other) = default;
+
+    // assign
+    constexpr basic_zstring_span& operator=(const basic_zstring_span& other) = default;
+
+    // move assign
+    constexpr basic_zstring_span& operator=(basic_zstring_span&& other) = default;
+
+    constexpr bool empty() const noexcept { return false; }
+
+    constexpr string_span_type as_string_span() const noexcept
+    {
+        return {span_.data(), span_.size() - 1};
+    }
+    constexpr string_span_type ensure_z() const { return gsl::ensure_z(span_); }
+
+    constexpr const_zstring_type assume_z() const noexcept { return span_.data(); }
+
+private:
+    impl_type span_;
+};
+
+template <std::size_t Max = dynamic_extent>
+using zstring_span [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                                "information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_zstring_span<char, Max>;
+
+template <std::size_t Max = dynamic_extent>
+using wzstring_span [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                                 "information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_zstring_span<wchar_t, Max>;
+
+template <std::size_t Max = dynamic_extent>
+using u16zstring_span [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                                   "information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_zstring_span<char16_t, Max>;
+
+template <std::size_t Max = dynamic_extent>
+using u32zstring_span [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                                   "information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_zstring_span<char32_t, Max>;
+
+template <std::size_t Max = dynamic_extent>
+using czstring_span [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                                 "information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_zstring_span<const char, Max>;
+
+template <std::size_t Max = dynamic_extent>
+using cwzstring_span [[deprecated("string_span was removed from the C++ Core Guidelines. For more "
+                                  "information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_zstring_span<const wchar_t, Max>;
+
+template <std::size_t Max = dynamic_extent>
+using cu16zstring_span [[deprecated("string_span was removed from the C++ Core Guidelines. For "
+                                    "more information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_zstring_span<const char16_t, Max>;
+
+template <std::size_t Max = dynamic_extent>
+using cu32zstring_span [[deprecated("string_span was removed from the C++ Core Guidelines. For "
+                                    "more information, see isocpp/CppCoreGuidelines PR#1680")]] =
+    basic_zstring_span<const char32_t, Max>;
+
+// operator ==
+template <class CharT, std::size_t Extent, class T,
+          class = std::enable_if_t<
+              details::is_basic_string_span<T>::value ||
+              std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>>>::value>>
+bool operator==(const gsl::basic_string_span<CharT, Extent>& one, const T& other)
+{
+    const gsl::basic_string_span<std::add_const_t<CharT>> tmp(other);
+    return std::equal(one.begin(), one.end(), tmp.begin(), tmp.end());
+}
+
+template <class CharT, std::size_t Extent, class T,
+          class = std::enable_if_t<
+              !details::is_basic_string_span<T>::value &&
+              std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>>>::value>>
+bool operator==(const T& one, const gsl::basic_string_span<CharT, Extent>& other)
+{
+    const gsl::basic_string_span<std::add_const_t<CharT>> tmp(one);
+    return std::equal(tmp.begin(), tmp.end(), other.begin(), other.end());
+}
+
+// operator !=
+template <typename CharT, std::size_t Extent = dynamic_extent, typename T,
+          typename = std::enable_if_t<std::is_convertible<
+              T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value>>
+bool operator!=(gsl::basic_string_span<CharT, Extent> one, const T& other)
+{
+    return !(one == other);
+}
+
+template <
+    typename CharT, std::size_t Extent = dynamic_extent, typename T,
+    typename = std::enable_if_t<
+        std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value &&
+        !gsl::details::is_basic_string_span<T>::value>>
+bool operator!=(const T& one, gsl::basic_string_span<CharT, Extent> other)
+{
+    return !(one == other);
+}
+
+// operator<
+template <typename CharT, std::size_t Extent = dynamic_extent, typename T,
+          typename = std::enable_if_t<std::is_convertible<
+              T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value>>
+bool operator<(gsl::basic_string_span<CharT, Extent> one, const T& other)
+{
+    const gsl::basic_string_span<std::add_const_t<CharT>, Extent> tmp(other);
+    return std::lexicographical_compare(one.begin(), one.end(), tmp.begin(), tmp.end());
+}
+
+template <
+    typename CharT, std::size_t Extent = dynamic_extent, typename T,
+    typename = std::enable_if_t<
+        std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value &&
+        !gsl::details::is_basic_string_span<T>::value>>
+bool operator<(const T& one, gsl::basic_string_span<CharT, Extent> other)
+{
+    gsl::basic_string_span<std::add_const_t<CharT>, Extent> tmp(one);
+    return std::lexicographical_compare(tmp.begin(), tmp.end(), other.begin(), other.end());
+}
+
+#ifndef _MSC_VER
+
+// VS treats temp and const containers as convertible to basic_string_span,
+// so the cases below are already covered by the previous operators
+
+template <
+    typename CharT, std::size_t Extent = dynamic_extent, typename T,
+    typename DataType = typename T::value_type,
+    typename = std::enable_if_t<
+        !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
+        std::is_convertible<DataType*, CharT*>::value &&
+        std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>,
+                     DataType>::value>>
+bool operator<(gsl::basic_string_span<CharT, Extent> one, const T& other)
+{
+    gsl::basic_string_span<std::add_const_t<CharT>, Extent> tmp(other);
+    return std::lexicographical_compare(one.begin(), one.end(), tmp.begin(), tmp.end());
+}
+
+template <
+    typename CharT, std::size_t Extent = dynamic_extent, typename T,
+    typename DataType = typename T::value_type,
+    typename = std::enable_if_t<
+        !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
+        std::is_convertible<DataType*, CharT*>::value &&
+        std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>,
+                     DataType>::value>>
+bool operator<(const T& one, gsl::basic_string_span<CharT, Extent> other)
+{
+    gsl::basic_string_span<std::add_const_t<CharT>, Extent> tmp(one);
+    return std::lexicographical_compare(tmp.begin(), tmp.end(), other.begin(), other.end());
+}
+#endif
+
+// operator <=
+template <typename CharT, std::size_t Extent = dynamic_extent, typename T,
+          typename = std::enable_if_t<std::is_convertible<
+              T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value>>
+bool operator<=(gsl::basic_string_span<CharT, Extent> one, const T& other)
+{
+    return !(other < one);
+}
+
+template <
+    typename CharT, std::size_t Extent = dynamic_extent, typename T,
+    typename = std::enable_if_t<
+        std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value &&
+        !gsl::details::is_basic_string_span<T>::value>>
+bool operator<=(const T& one, gsl::basic_string_span<CharT, Extent> other)
+{
+    return !(other < one);
+}
+
+#ifndef _MSC_VER
+
+// VS treats temp and const containers as convertible to basic_string_span,
+// so the cases below are already covered by the previous operators
+
+template <
+    typename CharT, std::size_t Extent = dynamic_extent, typename T,
+    typename DataType = typename T::value_type,
+    typename = std::enable_if_t<
+        !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
+        std::is_convertible<DataType*, CharT*>::value &&
+        std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>,
+                     DataType>::value>>
+bool operator<=(gsl::basic_string_span<CharT, Extent> one, const T& other)
+{
+    return !(other < one);
+}
+
+template <
+    typename CharT, std::size_t Extent = dynamic_extent, typename T,
+    typename DataType = typename T::value_type,
+    typename = std::enable_if_t<
+        !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
+        std::is_convertible<DataType*, CharT*>::value &&
+        std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>,
+                     DataType>::value>>
+bool operator<=(const T& one, gsl::basic_string_span<CharT, Extent> other)
+{
+    return !(other < one);
+}
+#endif
+
+// operator>
+template <typename CharT, std::size_t Extent = dynamic_extent, typename T,
+          typename = std::enable_if_t<std::is_convertible<
+              T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value>>
+bool operator>(gsl::basic_string_span<CharT, Extent> one, const T& other)
+{
+    return other < one;
+}
+
+template <
+    typename CharT, std::size_t Extent = dynamic_extent, typename T,
+    typename = std::enable_if_t<
+        std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value &&
+        !gsl::details::is_basic_string_span<T>::value>>
+bool operator>(const T& one, gsl::basic_string_span<CharT, Extent> other)
+{
+    return other < one;
+}
+
+#ifndef _MSC_VER
+
+// VS treats temp and const containers as convertible to basic_string_span,
+// so the cases below are already covered by the previous operators
+
+template <
+    typename CharT, std::size_t Extent = dynamic_extent, typename T,
+    typename DataType = typename T::value_type,
+    typename = std::enable_if_t<
+        !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
+        std::is_convertible<DataType*, CharT*>::value &&
+        std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>,
+                     DataType>::value>>
+bool operator>(gsl::basic_string_span<CharT, Extent> one, const T& other)
+{
+    return other < one;
+}
+
+template <
+    typename CharT, std::size_t Extent = dynamic_extent, typename T,
+    typename DataType = typename T::value_type,
+    typename = std::enable_if_t<
+        !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
+        std::is_convertible<DataType*, CharT*>::value &&
+        std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>,
+                     DataType>::value>>
+bool operator>(const T& one, gsl::basic_string_span<CharT, Extent> other)
+{
+    return other < one;
+}
+#endif
+
+// operator >=
+template <typename CharT, std::size_t Extent = dynamic_extent, typename T,
+          typename = std::enable_if_t<std::is_convertible<
+              T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value>>
+bool operator>=(gsl::basic_string_span<CharT, Extent> one, const T& other)
+{
+    return !(one < other);
+}
+
+template <
+    typename CharT, std::size_t Extent = dynamic_extent, typename T,
+    typename = std::enable_if_t<
+        std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value &&
+        !gsl::details::is_basic_string_span<T>::value>>
+bool operator>=(const T& one, gsl::basic_string_span<CharT, Extent> other)
+{
+    return !(one < other);
+}
+
+#ifndef _MSC_VER
+
+// VS treats temp and const containers as convertible to basic_string_span,
+// so the cases below are already covered by the previous operators
+
+template <
+    typename CharT, std::size_t Extent = dynamic_extent, typename T,
+    typename DataType = typename T::value_type,
+    typename = std::enable_if_t<
+        !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
+        std::is_convertible<DataType*, CharT*>::value &&
+        std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>,
+                     DataType>::value>>
+bool operator>=(gsl::basic_string_span<CharT, Extent> one, const T& other)
+{
+    return !(one < other);
+}
+
+template <
+    typename CharT, std::size_t Extent = dynamic_extent, typename T,
+    typename DataType = typename T::value_type,
+    typename = std::enable_if_t<
+        !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
+        std::is_convertible<DataType*, CharT*>::value &&
+        std::is_same<std::decay_t<decltype(std::declval<T>().size(), *std::declval<T>().data())>,
+                     DataType>::value>>
+bool operator>=(const T& one, gsl::basic_string_span<CharT, Extent> other)
+{
+    return !(one < other);
+}
+#endif
+} // namespace gsl
+
+#if defined(_MSC_VER) && !defined(__clang__)
+#pragma warning(pop)
+
+#endif // _MSC_VER
+
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+#endif // GSL_STRING_SPAN_H

include/gsl/util

@@ -1,4 +1,3 @@
-// -*- C++ -*-
 ///////////////////////////////////////////////////////////////////////////////
 //
 // Copyright (c) 2015 Microsoft Corporation. All rights reserved.
@@ -18,12 +17,11 @@
 #ifndef GSL_UTIL_H
 #define GSL_UTIL_H
 
-#include "./assert" // for Expects
+#include "assert" // for Expects
 
+#include <array>
 #include <cstddef>          // for ptrdiff_t, size_t
 #include <initializer_list> // for initializer_list
-#include <iterator>         // for iterator_traits
-#include <limits>           // for numeric_limits
 #include <type_traits>      // for is_signed, integral_constant
 #include <utility>          // for exchange, forward
 
@@ -41,14 +39,6 @@
 
 #endif // _MSC_VER
 
-// Turn off clang unsafe buffer warnings as all accessed are guarded by runtime checks
-#if defined(__clang__)
-#if __has_warning("-Wunsafe-buffer-usage")
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wunsafe-buffer-usage"
-#endif // __has_warning("-Wunsafe-buffer-usage")
-#endif // defined(__clang__)
-
 #if defined(__cplusplus) && (__cplusplus >= 201703L)
 #define GSL_NODISCARD [[nodiscard]]
 #else
@@ -61,39 +51,6 @@
 #define GSL_INLINE
 #endif
 
-#if defined(__has_cpp_attribute)
-#if __has_cpp_attribute(deprecated)
-#define GSL_DEPRECATED(msg) [[deprecated(msg)]]
-#endif // __has_cpp_attribute(deprecated)
-#endif // defined(__has_cpp_attribute)
-
-#if !defined(GSL_DEPRECATED)
-#if defined(__cplusplus)
-#if __cplusplus >= 201309L
-#define GSL_DEPRECATED(msg) [[deprecated(msg)]]
-#endif // __cplusplus >= 201309L
-#endif // defined(__cplusplus)
-#endif // !defined(GSL_DEPRECATED)
-
-#if !defined(GSL_DEPRECATED)
-#if defined(_MSC_VER)
-#define GSL_DEPRECATED(msg) __declspec(deprecated(msg))
-#elif defined(__GNUC__)
-#define GSL_DEPRECATED(msg) __attribute__((deprecated(msg)))
-#endif // defined(_MSC_VER)
-#endif // !defined(GSL_DEPRECATED)
-
-#if !defined(GSL_DEPRECATED)
-#define GSL_DEPRECATED(msg)
-#endif // !defined(GSL_DEPRECATED)
-
-#if __cplusplus >= 202002L
-#define GSL_CONSTEXPR_SINCE_CPP20 constexpr
-#else // ^^^ since C++20 /// before C++20 vvv
-#define GSL_BEFORE_CPP20
-#define GSL_CONSTEXPR_SINCE_CPP20
-#endif // __cplusplus >= 202002L
-
 namespace gsl
 {
 //
@@ -103,71 +60,53 @@ namespace gsl
 // index type for all container indexes/subscripts/sizes
 using index = std::ptrdiff_t;
 
-namespace details
-{
-    template <typename...>
-    using void_t = void;
-
-    template <typename T, typename = void>
-    struct is_iterator : std::false_type
-    {
-    };
-
-    template <typename T>
-    struct is_iterator<T, void_t<typename std::iterator_traits<T>::value_type>> : std::true_type
-    {
-    };
-
-    template <typename T, typename = void>
-    struct is_fwd_iterator : std::false_type
-    {
-    };
-
-    template <typename T>
-    struct is_fwd_iterator<T, void_t<typename std::iterator_traits<T>::iterator_category>>
-        : std::integral_constant<
-              bool, std::is_base_of<std::forward_iterator_tag,
-                                    typename std::iterator_traits<T>::iterator_category>::value>
-    {
-    };
-} // namespace details
-
 // final_action allows you to ensure something gets run at the end of a scope
 template <class F>
 class final_action
 {
 public:
-    explicit final_action(const F& ff) noexcept : f{ff} {}
-    explicit final_action(F&& ff) noexcept : f{std::move(ff)} {}
+    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");
 
-    ~final_action() noexcept
-    {
-        if (invoke) f();
-    }
+    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))
+        : f_(std::move(other.f_)), invoke_(std::exchange(other.invoke_, false))
     {}
 
     final_action(const final_action&) = delete;
-    void operator=(const final_action&) = delete;
-    void operator=(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;
+    F f_;
+    bool invoke_{true};
 };
 
 // finally() - convenience function to generate a final_action
 template <class F>
-GSL_NODISCARD auto finally(F&& f) noexcept
+GSL_NODISCARD final_action<typename std::remove_cv<typename std::remove_reference<F>::type>::type>
+finally(F&& f) noexcept
 {
-    return final_action<std::decay_t<F>>{std::forward<F>(f)};
+    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) constexpr T narrow_cast(U&& u) noexcept
+// 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));
 }
@@ -176,17 +115,22 @@ GSL_SUPPRESS(type.1) constexpr T narrow_cast(U&& u) noexcept
 // at() - Bounds-checked way of accessing builtin arrays, std::array, std::vector
 //
 template <class T, std::size_t N>
-GSL_SUPPRESS(bounds.4) GSL_SUPPRESS(bounds.2) constexpr T& at(T (&arr)[N], const index i)
+// 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)
 {
-    static_assert(N <= static_cast<std::size_t>((std::numeric_limits<std::ptrdiff_t>::max)()),
-                  "We only support arrays up to PTRDIFF_MAX bytes.");
     Expects(i >= 0 && i < narrow_cast<index>(N));
     return arr[narrow_cast<std::size_t>(i)];
 }
 
 template <class Cont>
-GSL_SUPPRESS(bounds.4) GSL_SUPPRESS(bounds.2) constexpr auto at(Cont& cont, const index i)
-    -> decltype(cont[cont.size()])
+// 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()));
     using size_type = decltype(cont.size());
@@ -194,25 +138,21 @@ GSL_SUPPRESS(bounds.4) GSL_SUPPRESS(bounds.2) constexpr auto at(Cont& cont, cons
 }
 
 template <class T>
-GSL_SUPPRESS(bounds.1) constexpr T at(const std::initializer_list<T> cont, const index i)
+// 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()));
     return *(cont.begin() + i);
 }
 
-template <class T, std::enable_if_t<std::is_move_assignable<T>::value &&
-                                    std::is_move_constructible<T>::value>>
-void swap(T& a, T& b)
-{
-    std::swap(a, b);
-}
-
 #if defined(__cpp_lib_span) && __cpp_lib_span >= 202002L
-template <class T, std::size_t extent = std::dynamic_extent>
+template <class T, size_t extent = std::dynamic_extent>
 constexpr auto at(std::span<T, extent> sp, const index i) -> decltype(sp[sp.size()])
 {
     Expects(i >= 0 && i < narrow_cast<index>(sp.size()));
-    return sp[gsl::narrow_cast<std::size_t>(i)];
+    return sp[gsl::narrow_cast<size_t>(i)];
 }
 #endif // __cpp_lib_span >= 202002L
 } // namespace gsl
@@ -223,10 +163,4 @@ constexpr auto at(std::span<T, extent> sp, const index i) -> decltype(sp[sp.size
 
 #endif // _MSC_VER
 
-#if defined(__clang__)
-#if __has_warning("-Wunsafe-buffer-usage")
-#pragma clang diagnostic pop
-#endif // __has_warning("-Wunsafe-buffer-usage")
-#endif // defined(__clang__)
-
 #endif // GSL_UTIL_H

include/gsl/zstring

@@ -1,58 +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_ZSTRING_H
-#define GSL_ZSTRING_H
-
-#include "./span_ext" // for dynamic_extent
-
-#include <cstddef> // for size_t, nullptr_t
-
-namespace gsl
-{
-//
-// czstring and wzstring
-//
-// These are "tag" typedefs for C-style strings (i.e. null-terminated character arrays)
-// that allow static analysis to help find bugs.
-//
-// There are no additional features/semantics that we can find a way to add inside the
-// type system for these types that will not either incur significant runtime costs or
-// (sometimes needlessly) break existing programs when introduced.
-//
-
-template <typename CharT, std::size_t Extent = dynamic_extent>
-using basic_zstring = CharT*;
-
-using czstring = basic_zstring<const char, dynamic_extent>;
-
-using cwzstring = basic_zstring<const wchar_t, dynamic_extent>;
-
-using cu16zstring = basic_zstring<const char16_t, dynamic_extent>;
-
-using cu32zstring = basic_zstring<const char32_t, dynamic_extent>;
-
-using zstring = basic_zstring<char, dynamic_extent>;
-
-using wzstring = basic_zstring<wchar_t, dynamic_extent>;
-
-using u16zstring = basic_zstring<char16_t, dynamic_extent>;
-
-using u32zstring = basic_zstring<char32_t, dynamic_extent>;
-
-} // namespace gsl
-
-#endif // GSL_ZSTRING_H

pipelines/jobs.yml

@@ -0,0 +1,43 @@
+parameters:
+  CXXVersions: [ 14, 17, 20 ]
+  buildTypes: [ 'Debug', 'Release' ]
+  image: ''
+
+  compiler: ''
+  compilerVersions: ["default"] # if default value, simply uses whatever version is on the machine.
+                                # the text of this default value doesn't actually matter.
+  setupfile: ''
+  extraCmakeArgs: ''
+
+jobs:
+- ${{ each compilerVersion in parameters.compilerVersions }}:
+  - ${{ each CXXVersion in parameters.CXXVersions }}:
+    - ${{ each buildType in parameters.buildTypes }}:
+      - job:
+        displayName: ${{ format('{0} {1} C++{2} {3}', parameters.compiler, compilerVersion, CXXVersion, buildType) }}
+        pool:
+            vmImage: ${{ parameters.image }}
+        continueOnError: false
+
+        steps:
+          - ${{ if not(eq(parameters.setupfile, '')) }}:
+            - template: ${{ parameters.setupfile }}
+              parameters:
+                version: ${{ compilerVersion }}
+
+          - task: CMake@1
+            name: Configure
+            inputs:
+              workingDirectory: build
+              cmakeArgs: '-DGSL_CXX_STANDARD=${{ CXXVersion }} -DCMAKE_BUILD_TYPE=${{ buildType }} -DCI_TESTING:BOOL=ON -DCMAKE_VERBOSE_MAKEFILE:BOOL=ON -Werror=dev ${{ parameters.extraCmakeArgs }} .. '
+
+          - task: CMake@1
+            name: Build
+            inputs:
+              workingDirectory: build
+              cmakeArgs: '--build . '
+
+          - script: ctest . --output-on-failure --no-compress-output
+            name: CTest
+            workingDirectory: build
+            failOnStderr: true

pipelines/setup_apple.yml

@@ -0,0 +1,9 @@
+parameters:
+    version: 0
+
+steps:
+  - script: |
+      if [ "${{ parameters.version }}" != "default" ]; then sudo xcode-select -switch /Applications/Xcode_${{ parameters.version }}.app; fi
+
+    displayName: "Setup Xcode Version"
+    failOnStderr: true

pipelines/setup_clang.yml

@@ -0,0 +1,13 @@
+parameters:
+    version: 0
+
+steps:
+  - script: |
+      echo "##vso[task.setvariable variable=CXX;]${CXX}"
+      echo "##vso[task.setvariable variable=CC;]${CC}"
+
+    displayName: "Setup Clang Version"
+    failOnStderr: true
+    env:
+      CC: clang-${{ parameters.version }}
+      CXX: clang++-${{ parameters.version }}

pipelines/setup_gcc.yml

@@ -0,0 +1,14 @@
+parameters:
+    version: 0
+
+steps:
+  - script: |
+      echo "##vso[task.setvariable variable=CXX;]${CXX}"
+      echo "##vso[task.setvariable variable=CC;]${CC}"
+      if [ "${{ parameters.version }}" = "11" ]; then sudo apt-get install $CXX; fi
+
+    displayName: "Setup GCC Version"
+    failOnStderr: true
+    env:
+      CC: gcc-${{ parameters.version }}
+      CXX: g++-${{ parameters.version }}

scripts/apply-formatting.bat

@@ -1,13 +0,0 @@
-@echo off
-setlocal enabledelayedexpansion
-
-"%VCINSTALLDIR%Tools\Llvm\bin\clang-format" -version
-if %errorlevel% neq 0 (
-    echo [ERROR] clang-format not found, script should be called from a visual studio developer command prompt.
-    exit /b %errorlevel%
-)
-
-for %%f in (include\gsl\* tests\*.h tests\*.cpp) do (
-    echo formatting %%f
-    "%VCINSTALLDIR%Tools\Llvm\bin\clang-format" -i --assume-filename x.cpp "%%f"
-)

scripts/apply-formatting.sh

@@ -1,18 +0,0 @@
-#!/bin/bash
-
-set -euo pipefail
-
-cf=clang-format-$(grep -i 'CLANG_VERSION:' .github/workflows/clang-format.yml | sed -E 's/.*"([^"]+)".*/\1/')
-readonly cf
-
-if ! "${cf}" -version; then
-	echo "[ERROR] clang-format not found. Please install it using: sudo apt install ${cf}"
-	exit 1
-fi
-
-{
-	find include/gsl -type f
-	find tests -type f \( -name '*.cpp' -o -name '*.h' \)
-} | xargs "${cf}" -i --assume-filename=x.cpp --verbose
-
-find scripts -type f -name '*.sh' -print -exec shfmt -w {} \;

tests/CMakeLists.txt

@@ -1,12 +1,7 @@
-cmake_minimum_required(VERSION 3.14...3.16)
+cmake_minimum_required(VERSION 3.0.2)
 
-project(GSLTests LANGUAGES CXX)
-
-set(GSL_CXX_STANDARD "14" CACHE STRING "Use c++ standard")
-
-set(CMAKE_CXX_STANDARD ${GSL_CXX_STANDARD})
-set(CMAKE_CXX_EXTENSIONS OFF)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
+project(GSLTests CXX)
+enable_testing()  # again, for support standalone testing
 
 include(FindPkgConfig)
 include(ExternalProject)
@@ -57,14 +52,10 @@ if (NOT GTestMain_FOUND)
 endif()
 
 if (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
-    find_package(Microsoft.GSL CONFIG REQUIRED)
-    enable_testing()
-
-    if (NOT DEFINED Microsoft.GSL_VERSION)
-        message(FATAL_ERROR "Microsoft.GSL_VERSION not defined!")
-    endif()
-
-    message(STATUS "Microsoft.GSL_VERSION = ${Microsoft.GSL_VERSION}")
+    # CMake has been started independently in this directory with tests. Do
+    # import the globally installed Guidelines Support Library and test it
+    # instead of the current version from the include/ folder.
+    find_package(Microsoft.GSL REQUIRED)
 endif()
 
 if (MSVC AND (GSL_CXX_STANDARD GREATER_EQUAL 17))
@@ -110,19 +101,15 @@ 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-switch-default # GTest EXPECT_DEATH
           $<$<EQUAL:${GSL_CXX_STANDARD},14>: # no support for [[maybe_unused]]
             -Wno-unused-member-function
             -Wno-unused-variable
-            $<$<VERSION_EQUAL:$<CXX_COMPILER_VERSION>,15.0.1>:
-              -Wno-deprecated # False positive in MSVC Clang 15.0.1 raises a C++17 warning
-            >
           >
         >
     )
     check_cxx_compiler_flag("-Wno-reserved-identifier" WARN_RESERVED_ID)
     if (WARN_RESERVED_ID)
-      target_compile_options(gsl_tests_config INTERFACE "-Wno-reserved-identifier")
+        target_compile_options(gsl_tests_config INTERFACE "-Wno-reserved-identifier")
     endif()
 else()
     target_compile_options(gsl_tests_config INTERFACE
@@ -147,11 +134,9 @@ else()
           -Wno-global-constructors # GTest
           -Wno-missing-prototypes
           -Wno-padded
-          -Wno-switch-default
           -Wno-unknown-attributes
           -Wno-used-but-marked-unused # GTest EXPECT_DEATH
           -Wno-weak-vtables
-          -Wno-poison-system-directories
           $<$<EQUAL:${GSL_CXX_STANDARD},14>: # no support for [[maybe_unused]]
             -Wno-unused-member-function
             -Wno-unused-variable
@@ -189,33 +174,33 @@ else()
         >
     )
 endif(MSVC)
-check_cxx_compiler_flag("-Wno-unsafe-buffer-usage" WARN_UNSAFE_BUFFER)
-if (WARN_UNSAFE_BUFFER)
-  # This test uses very greedy heuristics such as "no pointer arithmetic on raw buffer"
-  target_compile_options(gsl_tests_config INTERFACE "-Wno-unsafe-buffer-usage")
-endif()
 
 # for tests to find the gtest header
 target_include_directories(gsl_tests_config SYSTEM INTERFACE
     googletest/googletest/include
 )
 
-# Individually build and register each test source (except no_exception_ensure_tests.cpp)
-# no_exception_ensure_tests.cpp is built separately with exceptions disabled
-file(GLOB GSL_TEST_SOURCES CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp")
-list(FILTER GSL_TEST_SOURCES EXCLUDE REGEX "no_exception_ensure_tests\\.cpp$")
+add_executable(gsl_tests
+    algorithm_tests.cpp
+    assertion_tests.cpp
+    at_tests.cpp
+    byte_tests.cpp
+    notnull_tests.cpp
+    owner_tests.cpp
+    span_compatibility_tests.cpp
+    span_ext_tests.cpp
+    span_tests.cpp
+    strict_notnull_tests.cpp
+    string_span_tests.cpp
+    utils_tests.cpp
+)
 
-foreach(src IN LISTS GSL_TEST_SOURCES)
-  get_filename_component(test_name "${src}" NAME_WE)
-  add_executable(${test_name} ${src})
-  target_link_libraries(${test_name}
+target_link_libraries(gsl_tests
     Microsoft.GSL::GSL
     gsl_tests_config
     ${GTestMain_LIBRARIES}
-  )
-  add_test(NAME ${test_name} COMMAND ${test_name})
-  set_target_properties(${test_name} PROPERTIES FOLDER "tests")
-endforeach()
+)
+add_test(gsl_tests gsl_tests)
 
 # No exception tests
 
@@ -249,16 +234,11 @@ if(MSVC) # MSVC or simulating MSVC
           -Wno-c++98-compat-pedantic
           -Wno-missing-prototypes
           -Wno-unknown-attributes
-          $<$<EQUAL:${GSL_CXX_STANDARD},14>:
-            $<$<VERSION_EQUAL:$<CXX_COMPILER_VERSION>,15.0.1>: 
-              -Wno-deprecated # False positive in MSVC Clang 15.0.1 raises a C++17 warning
-            >
-          >
         >
     )
     check_cxx_compiler_flag("-Wno-reserved-identifier" WARN_RESERVED_ID)
     if (WARN_RESERVED_ID)
-      target_compile_options(gsl_tests_config_noexcept INTERFACE "-Wno-reserved-identifier")
+        target_compile_options(gsl_tests_config_noexcept INTERFACE "-Wno-reserved-identifier")
     endif()
 else()
     target_compile_options(gsl_tests_config_noexcept INTERFACE
@@ -281,7 +261,6 @@ else()
           -Wno-missing-prototypes
           -Wno-unknown-attributes
           -Wno-weak-vtables
-          -Wno-poison-system-directories
         >
         $<$<CXX_COMPILER_ID:GNU>:
           -Wdouble-promotion # float implicit to double
@@ -301,11 +280,6 @@ else()
         >
     )
 endif(MSVC)
-check_cxx_compiler_flag("-Wno-unsafe-buffer-usage" WARN_UNSAFE_BUFFER)
-if (WARN_UNSAFE_BUFFER)
-  # This test uses very greedy heuristics such as "no pointer arithmetic on raw buffer"
-  target_compile_options(gsl_tests_config_noexcept INTERFACE "-Wno-unsafe-buffer-usage")
-endif()
 
 add_executable(gsl_noexcept_tests no_exception_ensure_tests.cpp)
 target_link_libraries(gsl_noexcept_tests

tests/CMakeLists.txt.in

@@ -1,10 +1,10 @@
-cmake_minimum_required(VERSION 3.13)
+cmake_minimum_required(VERSION 3.0.2)
 project(googletest-download NONE)
 
 include(ExternalProject)
 ExternalProject_Add(googletest
   GIT_REPOSITORY    https://github.com/google/googletest.git
-  GIT_TAG           v1.14.0
+  GIT_TAG           1b18723e874b256c1e39378c6774a90701d70f7a
   SOURCE_DIR        "${CMAKE_CURRENT_BINARY_DIR}/googletest-src"
   BINARY_DIR        "${CMAKE_CURRENT_BINARY_DIR}/googletest-build"
   CONFIGURE_COMMAND ""

tests/algorithm_tests.cpp

@@ -188,7 +188,7 @@ TEST(algorithm_tests, incompatible_type)
     span<int> src_span_dyn(src);
     span<int, 4> src_span_static(src);
     span<int*> dst_span_dyn(dst);
-    span<int*, 4> dst_span_static(gsl::make_span(dst));
+    span<int*, 4> dst_span_static(dst);
 
     // every line should produce a compilation error
     copy(src_span_dyn, dst_span_dyn);

tests/assertion_tests.cpp

@@ -15,7 +15,7 @@
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "deathTestCommon.h"
-#include <gsl/assert> // for Ensures, Expects
+#include <gsl/assert> // for fail_fast (ptr only), Ensures, Expects
 #include <gtest/gtest.h>
 
 using namespace gsl;

tests/at_tests.cpp

@@ -20,7 +20,6 @@
 
 #include <array>            // for array
 #include <cstddef>          // for size_t
-#include <exception>        // for terminate
 #include <initializer_list> // for initializer_list
 #include <vector>           // for vector
 #if defined(__cplusplus) && __cplusplus >= 202002L
@@ -32,7 +31,7 @@
 TEST(at_tests, static_array)
 {
     int a[4] = {1, 2, 3, 4};
-    const int (&c_a)[4] = a;
+    const int(&c_a)[4] = a;
 
     for (int i = 0; i < 4; ++i)
     {
@@ -152,7 +151,7 @@ TEST(at_tests, std_span)
 static constexpr bool test_constexpr()
 {
     int a1[4] = {1, 2, 3, 4};
-    const int (&c_a1)[4] = a1;
+    const int(&c_a1)[4] = a1;
     std::array<int, 4> a2 = {1, 2, 3, 4};
     const std::array<int, 4>& c_a2 = a2;
 

tests/byte_tests.cpp

@@ -16,12 +16,8 @@
 
 #include <gtest/gtest.h>
 
-#define GSL_USE_STD_BYTE 0
 #include <gsl/byte> // for to_byte, to_integer, byte, operator&, ope...
 
-#include <type_traits>
-#include <utility>
-
 using namespace std;
 using namespace gsl;
 
@@ -37,46 +33,41 @@ int modify_both(gsl::byte& b, int& i)
 TEST(byte_tests, construction)
 {
     {
-        const gsl::byte b = static_cast<gsl::byte>(4);
+        const byte b = static_cast<byte>(4);
         EXPECT_TRUE(static_cast<unsigned char>(b) == 4);
     }
 
+    // clang-format off
+    GSL_SUPPRESS(es.49)
+    // clang-format on
     {
-        const gsl::byte b = gsl::byte(12);
+        const byte b = byte(12);
         EXPECT_TRUE(static_cast<unsigned char>(b) == 12);
     }
 
     {
-        const gsl::byte b = to_byte<12>();
+        const byte b = to_byte<12>();
         EXPECT_TRUE(static_cast<unsigned char>(b) == 12);
     }
     {
         const unsigned char uc = 12;
-        const gsl::byte b = to_byte(uc);
+        const byte b = to_byte(uc);
         EXPECT_TRUE(static_cast<unsigned char>(b) == 12);
     }
 
 #if defined(__cplusplus) && (__cplusplus >= 201703L)
     {
-        const gsl::byte b{14};
+        const byte b{14};
         EXPECT_TRUE(static_cast<unsigned char>(b) == 14);
     }
 #endif
-
-#ifdef CONFIRM_COMPILATION_ERRORS
-    to_byte(char{});
-    to_byte(3);
-    to_byte(3u);
-    to_byte<-1>();
-    to_byte<256u>();
-#endif
 }
 
 TEST(byte_tests, bitwise_operations)
 {
-    const gsl::byte b = to_byte<0xFF>();
+    const byte b = to_byte<0xFF>();
 
-    gsl::byte a = to_byte<0x00>();
+    byte a = to_byte<0x00>();
     EXPECT_TRUE((b | a) == to_byte<0xFF>());
     EXPECT_TRUE(a == to_byte<0x00>());
 
@@ -110,7 +101,7 @@ TEST(byte_tests, bitwise_operations)
 
 TEST(byte_tests, to_integer)
 {
-    const gsl::byte b = to_byte<0x12>();
+    const byte b = to_byte<0x12>();
 
     EXPECT_TRUE(0x12 == gsl::to_integer<char>(b));
     EXPECT_TRUE(0x12 == gsl::to_integer<short>(b));
@@ -129,50 +120,12 @@ TEST(byte_tests, to_integer)
 TEST(byte_tests, aliasing)
 {
     int i{0};
-    const int res = modify_both(reinterpret_cast<gsl::byte&>(i), i);
+    const int res = modify_both(reinterpret_cast<byte&>(i), i);
     EXPECT_TRUE(res == i);
 }
 
-#if __cplusplus >= 201703l
-using std::void_t;
-#else  // __cplusplus >= 201703l
-template <class...>
-using void_t = void;
-#endif // __cplusplus < 201703l
-
-template <typename U, typename = void>
-static constexpr bool LShiftCompilesFor = false;
-template <typename U>
-static constexpr bool LShiftCompilesFor<
-    U, void_t<decltype(gsl::operator<< <float>(declval<gsl::byte>(), declval<U>()))>> = true;
-static_assert(!LShiftCompilesFor<float>, "!LShiftCompilesFor<float>");
-
-template <typename U, typename = void>
-static constexpr bool RShiftCompilesFor = false;
-template <typename U>
-static constexpr bool RShiftCompilesFor<
-    U, void_t<decltype(gsl::operator>> <U>(declval<gsl::byte>(), declval<U>()))>> = true;
-static_assert(!RShiftCompilesFor<float>, "!RShiftCompilesFor<float>");
-
-template <typename U, typename = void>
-static constexpr bool LShiftAssignCompilesFor = false;
-template <typename U>
-static constexpr bool LShiftAssignCompilesFor<
-    U, void_t<decltype(gsl::operator<<= <U>(declval<gsl::byte&>(), declval<U>()))>> = true;
-static_assert(!LShiftAssignCompilesFor<float>, "!LShiftAssignCompilesFor<float>");
-
-template <typename U, typename = void>
-static constexpr bool RShiftAssignCompilesFor = false;
-template <typename U>
-static constexpr bool RShiftAssignCompilesFor<
-    U, void_t<decltype(gsl::operator>>= <U>(declval<gsl::byte&>(), declval<U>()))>> = true;
-static_assert(!RShiftAssignCompilesFor<float>, "!RShiftAssignCompilesFor<float>");
-
-template <typename U, typename = void>
-static constexpr bool ToIntegerCompilesFor = false;
-template <typename U>
-static constexpr bool ToIntegerCompilesFor<U, void_t<decltype(gsl::to_integer<U>(gsl::byte{}))>> =
-    true;
-static_assert(!ToIntegerCompilesFor<float>, "!ToIntegerCompilesFor<float>");
-
 } // namespace
+
+#ifdef CONFIRM_COMPILATION_ERRORS
+copy(src_span_static, dst_span_static);
+#endif

tests/constexpr_notnull_tests.cpp

@@ -1,75 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-// Copyright (c) 2025 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.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#include <gsl/pointers> // for not_null
-#include <gtest/gtest.h>
-
-#include <type_traits> // for declval
-
-using namespace gsl;
-
-namespace
-{
-constexpr bool comparison_test(const int* ptr1, const int* ptr2)
-{
-    const not_null<const int*> p1(ptr1);
-    const not_null<const int*> p1_same(ptr1);
-    const not_null<const int*> p2(ptr2);
-
-    // Testing operator==
-    const bool eq_result = (p1 == p1_same); // Should be true
-    const bool neq_result = (p1 != p2);     // Should be true
-
-    // Testing operator<= and operator>=
-    const bool le_result = (p1 <= p1_same); // Should be true
-    const bool ge_result = (p1 >= p1_same); // Should be true
-
-    // The exact comparison results will depend on pointer ordering,
-    // but we can verify that the basic equality checks work as expected
-    return eq_result && neq_result && le_result && ge_result;
-}
-
-constexpr bool workaround_test(const int* ptr1, const int* ptr2)
-{
-    const not_null<const int*> p1(ptr1);
-    const not_null<const int*> p1_same(ptr1);
-    const not_null<const int*> p2(ptr2);
-
-    // Using .get() to compare
-    const bool eq_result = (p1.get() == p1_same.get()); // Should be true
-    const bool neq_result = (p1.get() != p2.get());     // Should be true
-
-    return eq_result && neq_result;
-}
-} // namespace
-
-constexpr int test_value1 = 1;
-constexpr int test_value2 = 2;
-
-static_assert(comparison_test(&test_value1, &test_value2),
-              "not_null comparison operators should be constexpr");
-static_assert(workaround_test(&test_value1, &test_value2),
-              "not_null .get() comparison workaround should work");
-
-TEST(notnull_constexpr_tests, TestNotNullConstexprComparison)
-{
-    // This test simply verifies that the constexpr functions compile and run
-    // If we got here, it means the constexpr comparison operators are working
-    static const int value1 = 1;
-    static const int value2 = 2;
-    EXPECT_TRUE(comparison_test(&value1, &value2));
-    EXPECT_TRUE(workaround_test(&value1, &value2));
-}

tests/dyn_array_tests.cpp

@@ -1,684 +0,0 @@
-#include <gtest/gtest.h>
-
-#include "deathTestCommon.h"
-#include "gsl/dyn_array"
-#include <cstdlib>
-#include <exception>
-#include <gsl/dyn_array>
-#include <gsl/util>
-#include <iostream>
-#include <sstream>
-#include <type_traits>
-
-// Despite using <algorithm> and <ranges> utilities in this test, they
-// are not being included directly by this file as a test to ensure
-// transitive inclusion via <gsl/dyn_array>.
-
-static_assert(sizeof(gsl::dyn_array<int>) == 2 * sizeof(void*),
-              "gsl::dyn_array (with the default allocator) should be 16 bytes");
-
-#if defined(__cpp_lib_concepts) && (__cpp_lib_concepts >= 202002L)
-static_assert(std::input_iterator<gsl::dyn_array<int>::iterator>,
-              "gsl::dyn_array should expose a valid input_iterator");
-#endif /* __cpp_lib_concepts >= 202002L */
-
-#if defined(__cpp_lib_ranges) && (__cpp_lib_ranges >= 201911L)
-static_assert(std::ranges::input_range<gsl::dyn_array<int>>,
-              "gsl::dyn_array should be a valid input range");
-#endif /* __cpp_lib_ranges >= 201911L */
-
-TEST(dyn_array_tests, default_ctor)
-{
-    gsl::dyn_array<char> diamondbacks;
-    EXPECT_TRUE(diamondbacks.empty());
-    EXPECT_EQ(diamondbacks.size(), 0);
-    EXPECT_EQ(diamondbacks.data(), nullptr);
-}
-
-TEST(dyn_array_tests, count_ctor)
-{
-    gsl::dyn_array<char> athletics(10);
-    EXPECT_FALSE(athletics.empty());
-    EXPECT_EQ(athletics.size(), 10);
-    EXPECT_NE(athletics.data(), nullptr);
-
-    gsl::dyn_array<char> braves(0);
-    EXPECT_TRUE(braves.empty());
-    EXPECT_EQ(braves.size(), 0);
-    EXPECT_EQ(braves.data(), nullptr);
-    EXPECT_TRUE(std::all_of(braves.begin(), braves.end(), [](char c) { return c == char{}; }));
-}
-
-TEST(dyn_array_tests, count_value_ctor)
-{
-    gsl::dyn_array<char> orioles(10, 'c');
-    EXPECT_FALSE(orioles.empty());
-    EXPECT_EQ(orioles.size(), 10);
-    EXPECT_NE(orioles.data(), nullptr);
-    EXPECT_TRUE(std::all_of(orioles.begin(), orioles.end(), [](char c) { return c == 'c'; }));
-
-    gsl::dyn_array<int> redsox(10, 42);
-    EXPECT_FALSE(redsox.empty());
-    EXPECT_EQ(redsox.size(), 10);
-    EXPECT_NE(redsox.data(), nullptr);
-    EXPECT_TRUE(std::all_of(redsox.begin(), redsox.end(), [](int i) { return i == 42; }));
-}
-
-TEST(dyn_array_tests, inputit_ctor)
-{
-    std::vector<char> cubs(10, 'c');
-    gsl::dyn_array<char> whitesox(cubs.begin(), cubs.end());
-    EXPECT_FALSE(whitesox.empty());
-    EXPECT_EQ(whitesox.size(), cubs.size());
-    EXPECT_NE(whitesox.data(), nullptr);
-    EXPECT_TRUE(std::all_of(whitesox.begin(), whitesox.end(), [](char c) { return c == 'c'; }));
-}
-
-TEST(dyn_array_tests, copy_ctor)
-{
-    gsl::dyn_array<char> reds(10, 'c');
-    gsl::dyn_array<char> guardians(reds);
-    EXPECT_FALSE(guardians.empty());
-    EXPECT_EQ(guardians.size(), reds.size());
-    EXPECT_NE(guardians.data(), nullptr);
-    EXPECT_TRUE(std::all_of(guardians.begin(), guardians.end(), [](char c) { return c == 'c'; }));
-}
-
-TEST(dyn_array_tests, access_operator)
-{
-    gsl::dyn_array<char> rockies(10, 'c');
-    using ST = typename decltype(rockies)::size_type;
-    for (int i = 0; i < gsl::narrow<int>(rockies.size()); i++)
-        EXPECT_EQ(rockies[gsl::narrow<ST>(i)], 'c');
-    for (int i = 0; i < gsl::narrow<int>(rockies.size()); i++) rockies[gsl::narrow<ST>(i)] = 'r';
-    for (int i = 0; i < gsl::narrow<int>(rockies.size()); i++)
-        EXPECT_EQ(rockies[gsl::narrow<ST>(i)], 'r');
-    gsl::dyn_array<int> tigers(10);
-    for (int i = 0; i < gsl::narrow<int>(tigers.size()); i++) tigers[gsl::narrow<ST>(i)] = i;
-    for (int i = 0; i < gsl::narrow<int>(tigers.size()); i++)
-        EXPECT_EQ(tigers[gsl::narrow<ST>(i)], i);
-}
-
-TEST(dyn_array_tests, iterators)
-{
-    gsl::dyn_array<char> astros(10, 'c');
-    for (auto it = astros.begin(); it != astros.end(); it++) EXPECT_EQ(*it, 'c');
-    for (auto it = astros.begin(); it != astros.end(); it++) *it = 'r';
-    for (auto it = astros.begin(); it != astros.end(); it++) EXPECT_EQ(*it, 'r');
-    EXPECT_TRUE(std::all_of(astros.begin(), astros.end(), [](char c) { return c == 'r'; }));
-
-    gsl::dyn_array<char> royals(10, 'c');
-    for (auto it = royals.begin(); it != royals.end(); ++it) EXPECT_EQ(*it, 'c');
-    for (auto it = royals.begin(); it != royals.end(); ++it) *it = 'r';
-    for (auto it = royals.begin(); it != royals.end(); ++it) EXPECT_EQ(*it, 'r');
-    EXPECT_TRUE(std::all_of(royals.begin(), royals.end(), [](char c) { return c == 'r'; }));
-}
-
-TEST(dyn_array_tests, range_for)
-{
-    gsl::dyn_array<char> angels(10, 'c');
-    for (auto x : angels) EXPECT_EQ(x, 'c');
-    for (auto& x : angels) x = 'r';
-    for (auto x : angels) EXPECT_EQ(x, 'r');
-    EXPECT_TRUE(std::all_of(angels.begin(), angels.end(), [](char c) { return c == 'r'; }));
-}
-
-TEST(dyn_array_tests, use_std_algorithms)
-{
-    gsl::dyn_array<char> dodgers(26);
-    std::generate(dodgers.begin(), dodgers.end(), [i = 0]() mutable { return 'a' + i++; });
-    char ch = 'a';
-    for (auto x : dodgers) EXPECT_EQ(x, ch++);
-    EXPECT_EQ(std::find(dodgers.begin(), dodgers.end(), 'a'), dodgers.begin());
-    {
-        auto it = std::find(dodgers.begin(), dodgers.end(), 'c');
-        EXPECT_EQ(std::distance(dodgers.begin(), it), 'c' - 'a');
-        EXPECT_EQ(std::distance(it, dodgers.begin()), 'a' - 'c');
-    }
-    {
-        auto it = std::lower_bound(dodgers.begin(), dodgers.end(), 'j');
-        EXPECT_EQ(*it, 'j');
-        EXPECT_EQ(std::distance(dodgers.begin(), it), 'j' - 'a');
-        EXPECT_EQ(std::distance(it, dodgers.begin()), 'a' - 'j');
-    }
-    EXPECT_EQ(dodgers.begin(), std::begin(dodgers));
-    EXPECT_EQ(dodgers.end(), std::end(dodgers));
-}
-
-#if defined(__cpp_lib_constexpr_dynamic_alloc) && (__cpp_lib_constexpr_dynamic_alloc >= 201907L)
-constexpr auto default_constructed_count_dyn_array_is_constexpr()
-{
-    gsl::dyn_array<int> values(3);
-    return values.size() == 3 && values[0] == 0 && values[1] == 0 && values[2] == 0;
-}
-
-TEST(dyn_array_tests, constexprness)
-{
-    constexpr gsl::dyn_array<char> marlins;
-    static_assert(marlins == marlins);
-    static_assert(marlins.empty());
-    static_assert(marlins.size() == 0);
-    static_assert(marlins.data() == nullptr);
-    static_assert(marlins.begin() == marlins.end());
-    static_assert(std::distance(marlins.begin(), marlins.end()) == 0);
-    static_assert(default_constructed_count_dyn_array_is_constexpr());
-}
-#endif /* __cpp_lib_constexpr_dynamic_alloc >= 201907L */
-
-#if defined(__cpp_lib_ranges) && (__cpp_lib_ranges >= 201911L)
-TEST(dyn_array_tests, ranges)
-{
-    gsl::dyn_array<char> brewers(26);
-    std::ranges::generate(brewers, [c = 'a']() mutable { return c++; });
-    char ch = 'a';
-    for (auto x : brewers) EXPECT_EQ(x, ch++);
-    EXPECT_EQ(std::ranges::find(brewers, 'a'), std::ranges::begin(brewers));
-    {
-        auto it = std::ranges::find(brewers, 'c');
-        EXPECT_EQ(std::ranges::distance(std::ranges::begin(brewers), it), 'c' - 'a');
-        EXPECT_EQ(std::ranges::distance(it, std::ranges::begin(brewers)), 'a' - 'c');
-    }
-
-#if defined(__cpp_lib_containers_ranges) && (__cpp_lib_containers_ranges >= 202202L)
-    std::vector<char> twins(10, 'c');
-    gsl::dyn_array<char> mets(std::from_range, twins);
-    EXPECT_EQ(twins.size(), mets.size());
-    EXPECT_TRUE(std::ranges::all_of(mets, [](char c) { return c == 'c'; }));
-#endif /* __cpp_lib_containers_ranges >= 202202L */
-}
-#endif /* __cpp_lib_ranges >= 201911L */
-
-#if defined(__cpp_lib_constexpr_dynamic_alloc) && (__cpp_lib_constexpr_dynamic_alloc >= 201907L)
-template <typename T, unsigned N>
-struct ConstexprAllocator
-{
-    using value_type = T;
-
-    T buf[N]{};
-    std::size_t sz{};
-
-    constexpr ConstexprAllocator() = default;
-
-    template <typename U>
-    constexpr ConstexprAllocator(const ConstexprAllocator<U, N>&) noexcept : buf{}, sz{}
-    {}
-
-    template <typename U>
-    struct rebind
-    {
-        using other = ConstexprAllocator<U, N>;
-    };
-
-    constexpr auto allocate(std::size_t n) -> value_type*
-    {
-        auto addr = &buf[sz];
-        sz += n;
-        return addr;
-    }
-
-    constexpr void deallocate(value_type*, std::size_t) noexcept {}
-};
-
-template <typename T1, unsigned N1, typename T2, unsigned N2>
-constexpr auto operator==(const ConstexprAllocator<T1, N1>& lhs,
-                          const ConstexprAllocator<T2, N2>& rhs) noexcept
-{
-    return std::addressof(lhs) == std::addressof(rhs);
-}
-
-template <typename T1, unsigned N1, typename T2, unsigned N2>
-constexpr auto operator!=(const ConstexprAllocator<T1, N1>& lhs,
-                          const ConstexprAllocator<T2, N2>& rhs) noexcept
-{
-    return !(lhs == rhs);
-}
-#endif /* __cpp_lib_constexpr_dynamic_alloc >= 201907L */
-
-template <typename T>
-static int AllocCounter = 0;
-
-template <typename T>
-static int DeallocCounter = 0;
-
-struct LifetimeCounter
-{
-    static int alive_count;
-
-    int value{};
-
-    explicit LifetimeCounter(int v = 0) : value(v) { ++alive_count; }
-
-    LifetimeCounter(const LifetimeCounter& other) : value(other.value) { ++alive_count; }
-
-    ~LifetimeCounter() { --alive_count; }
-};
-
-int LifetimeCounter::alive_count = 0;
-
-struct DefaultConstructionCounter
-{
-    static int default_constructor_count;
-    static int copy_constructor_count;
-
-    int value{};
-
-    DefaultConstructionCounter() { ++default_constructor_count; }
-
-    DefaultConstructionCounter(const DefaultConstructionCounter& other) : value(other.value)
-    {
-        ++copy_constructor_count;
-    }
-
-    static void reset()
-    {
-        default_constructor_count = 0;
-        copy_constructor_count = 0;
-    }
-};
-
-int DefaultConstructionCounter::default_constructor_count = 0;
-int DefaultConstructionCounter::copy_constructor_count = 0;
-
-struct DefaultOnlyElement
-{
-    DefaultOnlyElement() = default;
-    DefaultOnlyElement(const DefaultOnlyElement&) = delete;
-    DefaultOnlyElement& operator=(const DefaultOnlyElement&) = delete;
-    DefaultOnlyElement(DefaultOnlyElement&&) = delete;
-    DefaultOnlyElement& operator=(DefaultOnlyElement&&) = delete;
-};
-
-struct ThrowOnCopy
-{
-    static int alive_count;
-    static int copy_count;
-    static int throw_on_copy_index;
-
-    int value{};
-
-    explicit ThrowOnCopy(int v = 0) : value(v) { ++alive_count; }
-
-    ThrowOnCopy(const ThrowOnCopy& other) : value(other.value)
-    {
-        if (copy_count == throw_on_copy_index)
-        {
-            ++copy_count;
-            throw 42;
-        }
-        ++copy_count;
-        ++alive_count;
-    }
-
-    ~ThrowOnCopy() { --alive_count; }
-};
-
-int ThrowOnCopy::alive_count = 0;
-int ThrowOnCopy::copy_count = 0;
-int ThrowOnCopy::throw_on_copy_index = -1;
-
-template <typename T>
-class Newocator
-{
-public:
-    using value_type = T;
-
-    Newocator() = default;
-
-    template <typename U>
-    Newocator(const Newocator<U>&) noexcept
-    {}
-
-    static void init()
-    {
-        AllocCounter<Newocator<T>> = 0;
-        DeallocCounter<Newocator<T>> = 0;
-    }
-
-    static void check() { EXPECT_EQ(AllocCounter<Newocator<T>>, DeallocCounter<Newocator<T>>); }
-
-    auto allocate(std::size_t n) -> value_type*
-    {
-        AllocCounter<Newocator<T>> ++;
-        return static_cast<value_type*>(::operator new(n * sizeof(value_type)));
-    }
-
-    void deallocate(value_type* p, std::size_t) noexcept
-    {
-        DeallocCounter<Newocator<T>> ++;
-        ::operator delete(p);
-    }
-
-    template <typename U>
-    struct rebind
-    {
-        using other = Newocator<U>;
-    };
-};
-
-template <typename T, typename U>
-constexpr auto operator==(const Newocator<T>&, const Newocator<U>&) noexcept
-{
-    return true;
-}
-
-template <typename T, typename U>
-constexpr auto operator!=(const Newocator<T>& lhs, const Newocator<U>& rhs) noexcept
-{
-    return !(lhs == rhs);
-}
-
-template <typename T>
-class OwnershipTrackingAllocator
-{
-public:
-    using value_type = T;
-
-    OwnershipTrackingAllocator() noexcept : owner_id(next_owner_id()) { ++next_owner_id(); }
-
-    explicit OwnershipTrackingAllocator(int owner) noexcept : owner_id(owner) {}
-
-    template <typename U>
-    OwnershipTrackingAllocator(const OwnershipTrackingAllocator<U>& other) noexcept
-        : owner_id(other.owner())
-    {}
-
-    auto allocate(std::size_t count) -> value_type*
-    {
-        static_assert(alignof(value_type) <= alignof(int),
-                      "test allocator only supports types with int-or-smaller alignment");
-        auto raw =
-            static_cast<unsigned char*>(::operator new(sizeof(int) + count * sizeof(value_type)));
-        *reinterpret_cast<int*>(raw) = owner_id;
-        ++allocation_count();
-        return reinterpret_cast<value_type*>(raw + sizeof(int));
-    }
-
-    void deallocate(value_type* pointer, std::size_t) noexcept
-    {
-        auto raw = reinterpret_cast<unsigned char*>(pointer) - sizeof(int);
-        if (*reinterpret_cast<int*>(raw) != owner_id) { ++mismatched_deallocation_count(); }
-        ++deallocation_count();
-        ::operator delete(raw);
-    }
-
-    auto owner() const noexcept { return owner_id; }
-
-    static void reset()
-    {
-        next_owner_id() = 1;
-        allocation_count() = 0;
-        deallocation_count() = 0;
-        mismatched_deallocation_count() = 0;
-    }
-
-    static auto mismatched_deallocations() { return mismatched_deallocation_count(); }
-
-private:
-    int owner_id;
-
-    static auto next_owner_id() -> int&
-    {
-        static int value = 1;
-        return value;
-    }
-
-    static auto allocation_count() -> int&
-    {
-        static int value = 0;
-        return value;
-    }
-
-    static auto deallocation_count() -> int&
-    {
-        static int value = 0;
-        return value;
-    }
-
-    static auto mismatched_deallocation_count() -> int&
-    {
-        static int value = 0;
-        return value;
-    }
-};
-
-template <typename T, typename U>
-constexpr auto operator==(const OwnershipTrackingAllocator<T>& lhs,
-                          const OwnershipTrackingAllocator<U>& rhs) noexcept
-{
-    return lhs.owner() == rhs.owner();
-}
-
-template <typename T, typename U>
-constexpr auto operator!=(const OwnershipTrackingAllocator<T>& lhs,
-                          const OwnershipTrackingAllocator<U>& rhs) noexcept
-{
-    return !(lhs == rhs);
-}
-
-TEST(dyn_array_tests, custom_allocator_models_allocator)
-{
-    using traits = std::allocator_traits<Newocator<char>>;
-    using ptr = traits::pointer;
-
-    static_assert(std::is_same<traits::value_type, char>::value, "allocator trait type mismatch");
-    static_assert(std::is_same<ptr, char*>::value, "allocator trait type mismatch");
-
-    Newocator<char> alloc;
-    auto p = traits::allocate(alloc, 1);
-    traits::deallocate(alloc, p, 1);
-
-#if defined(__cpp_lib_constexpr_dynamic_alloc) && (__cpp_lib_constexpr_dynamic_alloc >= 201907L)
-    using constexpr_traits = std::allocator_traits<ConstexprAllocator<char, 10>>;
-    static_assert(std::is_same<constexpr_traits::value_type, char>::value,
-                  "allocator trait type mismatch");
-#endif /* __cpp_lib_constexpr_dynamic_alloc >= 201907L */
-}
-
-TEST(dyn_array_tests, custom_allocator)
-{
-#if defined(__cpp_lib_constexpr_dynamic_alloc) && (__cpp_lib_constexpr_dynamic_alloc >= 201907L)
-    static constexpr gsl::dyn_array<char, ConstexprAllocator<char, 10>> mets(10, 'c');
-    static_assert(mets.size() == 10);
-    static_assert(mets[0] == 'c');
-    static_assert(std::all_of(std::begin(mets), std::end(mets), [](char c) { return c == 'c'; }));
-#endif /* __cpp_lib_constexpr_dynamic_alloc >= 201907L */
-
-    Newocator<char>::init();
-    {
-        gsl::dyn_array<char, Newocator<char>> yankees(10, 'c');
-        EXPECT_EQ(yankees.size(), 10);
-        EXPECT_TRUE(
-            std::all_of(std::begin(yankees), std::end(yankees), [](char c) { return c == 'c'; }));
-        yankees[0] = 'a';
-        yankees[1] = 'b';
-        EXPECT_EQ(yankees[0], 'a');
-        EXPECT_EQ(yankees[1], 'b');
-        EXPECT_EQ(yankees[2], 'c');
-        yankees.get_allocator().deallocate(yankees.get_allocator().allocate(1), 1);
-    }
-    Newocator<char>::check();
-}
-
-TEST(dyn_array_tests, non_trivial_elements_are_destroyed)
-{
-    LifetimeCounter::alive_count = 0;
-
-    {
-        gsl::dyn_array<LifetimeCounter> values(5, LifetimeCounter{7});
-        EXPECT_EQ(values.size(), 5);
-        EXPECT_EQ(LifetimeCounter::alive_count, 5);
-    }
-
-    EXPECT_EQ(LifetimeCounter::alive_count, 0);
-}
-
-TEST(dyn_array_tests, count_constructor_default_constructs_each_element)
-{
-    DefaultConstructionCounter::reset();
-
-    {
-        gsl::dyn_array<DefaultConstructionCounter> values(4);
-        EXPECT_EQ(values.size(), 4);
-    }
-
-    EXPECT_EQ(DefaultConstructionCounter::default_constructor_count, 4);
-    EXPECT_EQ(DefaultConstructionCounter::copy_constructor_count, 0);
-}
-
-#ifdef GSL_DYN_ARRAY_COMPILE_FAILURE_TESTS
-TEST(dyn_array_compile_failure_tests, count_constructor_accepts_default_constructible_only_elements)
-{
-    gsl::dyn_array<DefaultOnlyElement> values(4);
-    EXPECT_EQ(values.size(), 4);
-}
-#endif /* GSL_DYN_ARRAY_COMPILE_FAILURE_TESTS */
-
-TEST(dyn_array_tests, failed_element_construction_rolls_back)
-{
-    ThrowOnCopy::alive_count = 0;
-    ThrowOnCopy::copy_count = 0;
-    ThrowOnCopy::throw_on_copy_index = 2;
-
-    EXPECT_THROW((gsl::dyn_array<ThrowOnCopy>(5, ThrowOnCopy{1})), int);
-    EXPECT_EQ(ThrowOnCopy::alive_count, 0);
-
-    ThrowOnCopy::throw_on_copy_index = -1;
-}
-
-TEST(dyn_array_tests, init_list)
-{
-    gsl::dyn_array<char> phillies = {'a', 'b', 'c'};
-    EXPECT_EQ(phillies.size(), 3);
-    EXPECT_EQ(phillies[0], 'a');
-    EXPECT_EQ(phillies[1], 'b');
-    EXPECT_EQ(phillies[2], 'c');
-}
-
-TEST(dyn_array_tests, const_operations)
-{
-    const gsl::dyn_array<char> pirates{'a', 'b', 'c', 'd'};
-    EXPECT_EQ(pirates.size(), 4);
-    EXPECT_EQ(pirates[0], 'a');
-}
-
-TEST(dyn_array_tests, reverse_iterator)
-{
-    const gsl::dyn_array<char> padres{'a', 'b', 'c'};
-    auto it = std::rbegin(padres);
-    EXPECT_EQ(*it++, 'c');
-    EXPECT_EQ(*it++, 'b');
-    EXPECT_EQ(*it++, 'a');
-}
-
-TEST(dyn_array_tests, random_access_iterator_arithmetic)
-{
-    gsl::dyn_array<char> bluejays{'a', 'b', 'c', 'd'};
-
-    auto first = bluejays.begin();
-    auto third = first + 2;
-
-    EXPECT_EQ(*third, 'c');
-    EXPECT_EQ(third - first, 2);
-    EXPECT_EQ(*(third - 1), 'b');
-    EXPECT_EQ(*std::prev(third), 'b');
-}
-
-TEST(dyn_array_tests, random_access_iterator_arithmetic_accepts_negative_offsets)
-{
-    gsl::dyn_array<char> bluejays{'a', 'b', 'c', 'd'};
-
-    auto third = bluejays.begin() + 2;
-    char previous{};
-    char next{};
-
-    EXPECT_NO_THROW(previous = *(third + -1));
-    EXPECT_EQ(previous, 'b');
-
-    EXPECT_NO_THROW(next = *(third - -1));
-    EXPECT_EQ(next, 'd');
-}
-
-TEST(dyn_array_tests, input_iterator_constructor)
-{
-    std::istringstream stream{"n a t s"};
-    std::istream_iterator<char> first{stream};
-    const std::istream_iterator<char> last{};
-
-    gsl::dyn_array<char> nationals(first, last);
-
-    ASSERT_EQ(nationals.size(), 4);
-    EXPECT_EQ(nationals[0], 'n');
-    EXPECT_EQ(nationals[1], 'a');
-    EXPECT_EQ(nationals[2], 't');
-    EXPECT_EQ(nationals[3], 's');
-}
-
-TEST(dyn_array_tests, contract_violations)
-{
-    const auto terminateHandler = std::set_terminate([] {
-        std::cerr << "Expected Death. dyn_array_contract_violations";
-        std::abort();
-    });
-    const auto expected = GetExpectedDeathString(terminateHandler);
-
-    gsl::dyn_array<char> values(3, 'v');
-    gsl::dyn_array<char> other(3, 'o');
-
-    EXPECT_DEATH(values[values.size()], expected);
-    EXPECT_DEATH((void) *values.end(), expected);
-    EXPECT_DEATH(++values.end(), expected);
-    EXPECT_DEATH(--values.begin(), expected);
-    EXPECT_DEATH((void) (values.begin() == other.begin()), expected);
-}
-
-#ifdef _MSC_VER
-TEST(dyn_array_tests, unchecked_iterators)
-{
-    gsl::dyn_array<char> values;
-    const gsl::dyn_array<char> const_values(3, 'v');
-
-    EXPECT_TRUE((std::is_same<decltype(const_values._Unchecked_begin()), const char*>::value));
-    EXPECT_TRUE((std::is_same<decltype(const_values._Unchecked_end()), const char*>::value));
-
-    std::size_t count = 0;
-    for (const auto value : const_values)
-    {
-        EXPECT_EQ(value, 'v');
-        ++count;
-    }
-    EXPECT_EQ(count, const_values.size());
-
-    EXPECT_EQ(values._Unchecked_begin(), nullptr);
-    EXPECT_EQ(values._Unchecked_end(), nullptr);
-}
-#endif /* _MSC_VER */
-
-TEST(DynArrayTests, TypeConsistency)
-{
-    static_assert(std::is_same<gsl::dyn_array<int>::value_type, int>::value, "Value type mismatch");
-    static_assert(std::is_same<gsl::dyn_array<int>::reference, int&>::value,
-                  "Reference type mismatch");
-    static_assert(std::is_same<gsl::dyn_array<int>::const_reference, const int&>::value,
-                  "Const reference type mismatch");
-    static_assert(std::is_same<gsl::dyn_array<int>::iterator::value_type, int>::value,
-                  "Iterator value type mismatch");
-    static_assert(std::is_same<gsl::dyn_array<int>::iterator::reference, int&>::value,
-                  "Iterator reference type mismatch");
-    static_assert(std::is_same<gsl::dyn_array<int>::iterator::const_reference, const int&>::value,
-                  "Iterator const reference type mismatch");
-    static_assert(std::is_same<gsl::dyn_array<int>::size_type, std::size_t>::value,
-                  "Size type mismatch");
-    static_assert(std::is_same<gsl::dyn_array<int>::difference_type, std::ptrdiff_t>::value,
-                  "Difference type mismatch");
-}
-
-#if defined(__cpp_deduction_guides) && (__cpp_deduction_guides >= 201703L)
-TEST(dyn_array_tests, deduction_guides)
-{
-    std::vector<char> giants{10};
-#if defined(__cpp_lib_containers_ranges) && (__cpp_lib_containers_ranges >= 202202L)
-    gsl::dyn_array mariners(std::from_range, giants);
-#endif /* __cpp_lib_containers_ranges >= 202202L */
-    gsl::dyn_array cardinals(std::begin(giants), std::end(giants));
-}
-#endif /* __cpp_deduction_guides >= 201703L */

tests/notnull_tests.cpp

@@ -18,25 +18,16 @@
 
 #include <gsl/pointers> // for not_null, operator<, operator<=, operator>
 
-#include <algorithm>   // for addressof
-#include <cstdint>     // for uint16_t
-#include <memory>      // for shared_ptr, make_shared, operator<, opera...
-#include <sstream>     // for operator<<, ostringstream, basic_ostream:...
-#include <string>      // for basic_string, operator==, string, operator<<
-#include <type_traits> // for declval
-#include <typeinfo>    // for type_info
-#include <variant>     // for variant, monostate, get
+#include <algorithm> // for addressof
+#include <memory>    // for shared_ptr, make_shared, operator<, opera...
+#include <sstream>   // for operator<<, ostringstream, basic_ostream:...
+#include <stdint.h>  // for uint16_t
+#include <string>    // for basic_string, operator==, string, operator<<
+#include <typeinfo>  // for type_info
 
 #include "deathTestCommon.h"
 using namespace gsl;
 
-#if __cplusplus >= 201703l
-using std::void_t;
-#else  // __cplusplus >= 201703l
-template <class...>
-using void_t = void;
-#endif // __cplusplus < 201703l
-
 struct MyBase
 {
 };
@@ -61,7 +52,7 @@ template <typename T>
 struct CustomPtr
 {
     CustomPtr(T* p) : p_(p) {}
-    operator T*() const { return p_; }
+    operator T*() { return p_; }
     bool operator!=(std::nullptr_t) const { return p_ != nullptr; }
     T* p_ = nullptr;
 };
@@ -69,7 +60,9 @@ struct CustomPtr
 template <typename T, typename U>
 std::string operator==(CustomPtr<T> const& lhs, CustomPtr<U> const& rhs)
 {
-    GSL_SUPPRESS(type.1)
+    // clang-format off
+    GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
+    // clang-format on
     return reinterpret_cast<const void*>(lhs.p_) == reinterpret_cast<const void*>(rhs.p_) ? "true"
                                                                                           : "false";
 }
@@ -77,7 +70,9 @@ std::string operator==(CustomPtr<T> const& lhs, CustomPtr<U> const& rhs)
 template <typename T, typename U>
 std::string operator!=(CustomPtr<T> const& lhs, CustomPtr<U> const& rhs)
 {
-    GSL_SUPPRESS(type.1)
+    // clang-format off
+    GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
+    // clang-format on
     return reinterpret_cast<const void*>(lhs.p_) != reinterpret_cast<const void*>(rhs.p_) ? "true"
                                                                                           : "false";
 }
@@ -85,7 +80,9 @@ std::string operator!=(CustomPtr<T> const& lhs, CustomPtr<U> const& rhs)
 template <typename T, typename U>
 std::string operator<(CustomPtr<T> const& lhs, CustomPtr<U> const& rhs)
 {
-    GSL_SUPPRESS(type.1)
+    // clang-format off
+    GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
+    // clang-format on
     return reinterpret_cast<const void*>(lhs.p_) < reinterpret_cast<const void*>(rhs.p_) ? "true"
                                                                                          : "false";
 }
@@ -93,7 +90,9 @@ std::string operator<(CustomPtr<T> const& lhs, CustomPtr<U> const& rhs)
 template <typename T, typename U>
 std::string operator>(CustomPtr<T> const& lhs, CustomPtr<U> const& rhs)
 {
-    GSL_SUPPRESS(type.1)
+    // clang-format off
+    GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
+    // clang-format on
     return reinterpret_cast<const void*>(lhs.p_) > reinterpret_cast<const void*>(rhs.p_) ? "true"
                                                                                          : "false";
 }
@@ -101,7 +100,9 @@ std::string operator>(CustomPtr<T> const& lhs, CustomPtr<U> const& rhs)
 template <typename T, typename U>
 std::string operator<=(CustomPtr<T> const& lhs, CustomPtr<U> const& rhs)
 {
-    GSL_SUPPRESS(type.1)
+    // clang-format off
+    GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
+    // clang-format on
     return reinterpret_cast<const void*>(lhs.p_) <= reinterpret_cast<const void*>(rhs.p_) ? "true"
                                                                                           : "false";
 }
@@ -109,7 +110,9 @@ std::string operator<=(CustomPtr<T> const& lhs, CustomPtr<U> const& rhs)
 template <typename T, typename U>
 std::string operator>=(CustomPtr<T> const& lhs, CustomPtr<U> const& rhs)
 {
-    GSL_SUPPRESS(type.1)
+    // clang-format off
+    GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
+    // clang-format on
     return reinterpret_cast<const void*>(lhs.p_) >= reinterpret_cast<const void*>(rhs.p_) ? "true"
                                                                                           : "false";
 }
@@ -125,47 +128,28 @@ struct NonCopyableNonMovable
 
 namespace
 {
-GSL_SUPPRESS(f.4)
+// clang-format off
+GSL_SUPPRESS(f .4) // NO-FORMAT: attribute
+// clang-format on
 bool helper(not_null<int*> p) { return *p == 12; }
-GSL_SUPPRESS(f.4)
+// clang-format off
+GSL_SUPPRESS(f .4) // NO-FORMAT: attribute
+// clang-format on
 bool helper_const(not_null<const int*> p) { return *p == 12; }
 
 int* return_pointer() { return nullptr; }
 } // namespace
 
-template <typename U, typename = void>
-static constexpr bool CtorCompilesFor_A = false;
-template <typename U>
-static constexpr bool
-    CtorCompilesFor_A<U, void_t<decltype(gsl::not_null<void*>{std::declval<U>()})>> = true;
-
-template <typename U, int N, typename = void>
-static constexpr bool CtorCompilesFor_B = false;
-template <typename U, int N>
-static constexpr bool CtorCompilesFor_B<U, N, void_t<decltype(gsl::not_null<U>{N})>> = true;
-
-template <typename U, typename = void>
-static constexpr bool DefaultCtorCompilesFor = false;
-template <typename U>
-static constexpr bool DefaultCtorCompilesFor<U, void_t<decltype(gsl::not_null<U>{})>> = true;
-
-template <typename U, typename = void>
-static constexpr bool CtorCompilesFor_C = false;
-template <typename U>
-static constexpr bool
-    CtorCompilesFor_C<U, void_t<decltype(gsl::not_null<U*>{std::declval<std::unique_ptr<U>>()})>> =
-        true;
-
 TEST(notnull_tests, TestNotNullConstructors)
 {
     {
-        static_assert(CtorCompilesFor_A<void*>, "CtorCompilesFor_A<void*>");
-        static_assert(!CtorCompilesFor_A<std::nullptr_t>, "!CtorCompilesFor_A<std::nullptr_t>");
-        static_assert(!CtorCompilesFor_B<void*, 0>, "!CtorCompilesFor_B<void*, 0>");
-        static_assert(!DefaultCtorCompilesFor<void*>, "!DefaultCtorCompilesFor<void*>");
-        static_assert(!CtorCompilesFor_C<int>, "CtorCompilesFor_C<int>");
-
 #ifdef CONFIRM_COMPILATION_ERRORS
+        not_null<int*> p = nullptr;          // yay...does not compile!
+        not_null<std::vector<char>*> p1 = 0; // yay...does not compile!
+        not_null<int*> p2;                   // yay...does not compile!
+        std::unique_ptr<int> up = std::make_unique<int>(120);
+        not_null<int*> p3 = up;
+
         // Forbid non-nullptr assignable types
         not_null<std::vector<int>> f(std::vector<int>{1});
         not_null<int> z(10);
@@ -193,14 +177,6 @@ TEST(notnull_tests, TestNotNullConstructors)
         EXPECT_DEATH((not_null<decltype(pi)>(pi)), expected);
     }
 
-    {
-        // from unique pointer
-        not_null<std::unique_ptr<int>> x(
-            std::make_unique<int>(10)); // unique_ptr<int> is nullptr assignable
-
-        EXPECT_DEATH((not_null<std::unique_ptr<int>>(std::unique_ptr<int>{})), expected);
-    }
-
     {
         // from pointer to local
         int t = 42;
@@ -291,27 +267,6 @@ TEST(notnull_tests, TestNotNullostream)
     ostream_helper<std::string>("string");
 }
 
-template <typename U, typename V, typename = void>
-static constexpr bool AssignmentCompilesFor = false;
-template <typename U, typename V>
-static constexpr bool
-    AssignmentCompilesFor<U, V,
-                          void_t<decltype(std::declval<gsl::not_null<U*>&>().operator=(
-                              std::declval<gsl::not_null<V*>&>()))>> = true;
-
-template <typename U, typename V, typename = void>
-static constexpr bool SCastCompilesFor = false;
-template <typename U, typename V>
-static constexpr bool
-    SCastCompilesFor<U, V, void_t<decltype(static_cast<U*>(std::declval<gsl::not_null<V*>&>()))>> =
-        true;
-
-template <typename U, typename V, typename = void>
-static constexpr bool RCastCompilesFor = false;
-template <typename U, typename V>
-static constexpr bool RCastCompilesFor<
-    U, V, void_t<decltype(reinterpret_cast<U*>(std::declval<gsl::not_null<V*>&>()))>> = true;
-
 TEST(notnull_tests, TestNotNullCasting)
 {
     MyBase base;
@@ -324,30 +279,15 @@ TEST(notnull_tests, TestNotNullCasting)
     q = p; // allowed with heterogeneous copy ctor
     EXPECT_TRUE(q == p);
 
-    static_assert(AssignmentCompilesFor<MyBase, MyDerived>,
-                  "AssignmentCompilesFor<MyBase, MyDerived>");
-    static_assert(!AssignmentCompilesFor<MyBase, Unrelated>,
-                  "!AssignmentCompilesFor<MyBase, Unrelated>");
-    static_assert(!AssignmentCompilesFor<Unrelated, MyDerived>,
-                  "!AssignmentCompilesFor<Unrelated, MyDerived>");
-    static_assert(!AssignmentCompilesFor<MyDerived, MyBase>,
-                  "!AssignmentCompilesFor<MyDerived, MyBase>");
-
-    static_assert(SCastCompilesFor<MyDerived, MyDerived>, "SCastCompilesFor<MyDerived, MyDerived>");
-    static_assert(SCastCompilesFor<MyBase, MyDerived>, "SCastCompilesFor<MyBase, MyDerived>");
-    static_assert(!SCastCompilesFor<MyDerived, MyBase>, "!SCastCompilesFor<MyDerived, MyBase>");
-    static_assert(!SCastCompilesFor<Unrelated, MyDerived>,
-                  "!SCastCompilesFor<Unrelated, MyDerived>");
-    static_assert(!RCastCompilesFor<MyDerived, MyDerived>,
-                  "!SCastCompilesFor<MyDerived, MyDerived>");
-    static_assert(!RCastCompilesFor<Unrelated, MyDerived>,
-                  "!SCastCompilesFor<Unrelated, MyDerived>");
+#ifdef CONFIRM_COMPILATION_ERRORS
+    q = u; // no viable conversion possible between MyBase* and Unrelated*
+    p = q; // not possible to implicitly convert MyBase* to MyDerived*
 
+    not_null<Unrelated*> r = p;
+    not_null<Unrelated*> s = reinterpret_cast<Unrelated*>(p);
+#endif
     not_null<Unrelated*> t(reinterpret_cast<Unrelated*>(p.get()));
     EXPECT_TRUE(reinterpret_cast<void*>(p.get()) == reinterpret_cast<void*>(t.get()));
-
-    (void) static_cast<MyDerived*>(p);
-    (void) static_cast<MyBase*>(p);
 }
 
 TEST(notnull_tests, TestNotNullAssignment)
@@ -489,18 +429,6 @@ TEST(notnull_tests, TestNotNullCustomPtrComparison)
 
 #if defined(__cplusplus) && (__cplusplus >= 201703L)
 
-template <typename U, typename = void>
-static constexpr bool TypeDeductionCtorCompilesFor = false;
-template <typename U>
-static constexpr bool
-    TypeDeductionCtorCompilesFor<U, void_t<decltype(not_null{std::declval<U>()})>> = true;
-
-template <typename U, typename = void>
-static constexpr bool TypeDeductionHelperCompilesFor = false;
-template <typename U>
-static constexpr bool
-    TypeDeductionHelperCompilesFor<U, void_t<decltype(helper(not_null{std::declval<U>()}))>> = true;
-
 TEST(notnull_tests, TestNotNullConstructorTypeDeduction)
 {
     {
@@ -513,18 +441,6 @@ TEST(notnull_tests, TestNotNullConstructorTypeDeduction)
         EXPECT_TRUE(*x == 42);
     }
 
-    {
-        const int i = 42;
-
-        not_null x{&i};
-        static_assert(TypeDeductionHelperCompilesFor<int*>, "TypeDeductionHelperCompilesFor<int*>");
-        static_assert(!TypeDeductionHelperCompilesFor<const int*>,
-                      "!TypeDeductionHelperCompilesFor<const int*>");
-        helper_const(not_null{&i});
-
-        EXPECT_TRUE(*x == 42);
-    }
-
     {
         int i = 42;
         int* p = &i;
@@ -536,16 +452,6 @@ TEST(notnull_tests, TestNotNullConstructorTypeDeduction)
         EXPECT_TRUE(*x == 42);
     }
 
-    {
-        const int i = 42;
-        const int* p = &i;
-
-        not_null x{p};
-        helper_const(not_null{p});
-
-        EXPECT_TRUE(*x == 42);
-    }
-
     const auto terminateHandler = std::set_terminate([] {
         std::cerr << "Expected Death. TestNotNullConstructorTypeDeduction";
         std::abort();
@@ -575,35 +481,16 @@ TEST(notnull_tests, TestNotNullConstructorTypeDeduction)
         EXPECT_DEATH(helper_const(not_null{p}), expected);
     }
 
-    static_assert(TypeDeductionCtorCompilesFor<void*>, "TypeDeductionCtorCompilesFor<void*>");
-#if defined(_MSC_VER) && !defined(__clang__)
-    // Fails on gcc, clang, xcode, VS clang with
-    // "error : no type named 'type' in 'std::enable_if<false>'; 'enable_if' cannot be used to
-    // disable this declaration"
-    static_assert(!TypeDeductionCtorCompilesFor<std::nullptr_t>,
-                  "!TypeDeductionCtorCompilesFor<std::nullptr_t>");
-    static_assert(!TypeDeductionHelperCompilesFor<std::nullptr_t>,
-                  "!TypeDeductionHelperCompilesFor<std::nullptr_t>");
+#ifdef CONFIRM_COMPILATION_ERRORS
+    {
+        not_null x{nullptr};
+        helper(not_null{nullptr});
+        helper_const(not_null{nullptr});
+    }
 #endif
 }
-
-TEST(notnull_tests, TestVariantEmplace)
-{
-    int i = 0;
-    std::variant<std::monostate, not_null<int*>> v;
-    v.emplace<not_null<int*>>(&i);
-
-    EXPECT_FALSE(v.valueless_by_exception());
-    EXPECT_TRUE(v.index() == 1);
-    EXPECT_TRUE(std::get<not_null<int*>>(v) == &i);
-}
 #endif // #if defined(__cplusplus) && (__cplusplus >= 201703L)
 
-template <typename U, typename = void>
-static constexpr bool HelperCompilesFor = false;
-template <typename U>
-static constexpr bool HelperCompilesFor<U, void_t<decltype(helper(std::declval<U>()))>> = true;
-
 TEST(notnull_tests, TestMakeNotNull)
 {
     {
@@ -616,17 +503,6 @@ TEST(notnull_tests, TestMakeNotNull)
         EXPECT_TRUE(*x == 42);
     }
 
-    {
-        const int i = 42;
-
-        const auto x = make_not_null(&i);
-        static_assert(HelperCompilesFor<gsl::not_null<int*>>,
-                      "HelperCompilesFor<gsl::not_null<int*>>");
-        helper_const(make_not_null(&i));
-
-        EXPECT_TRUE(*x == 42);
-    }
-
     {
         int i = 42;
         int* p = &i;
@@ -638,18 +514,6 @@ TEST(notnull_tests, TestMakeNotNull)
         EXPECT_TRUE(*x == 42);
     }
 
-    {
-        const int i = 42;
-        const int* p = &i;
-
-        const auto x = make_not_null(p);
-        static_assert(!HelperCompilesFor<gsl::not_null<const int*>>,
-                      "!HelperCompilesFor<gsl::not_null<const int*>>");
-        helper_const(make_not_null(p));
-
-        EXPECT_TRUE(*x == 42);
-    }
-
     const auto terminateHandler = std::set_terminate([] {
         std::cerr << "Expected Death. TestMakeNotNull";
         std::abort();
@@ -692,45 +556,15 @@ TEST(notnull_tests, TestMakeNotNull)
 
 TEST(notnull_tests, TestStdHash)
 {
-    {
-        int x = 42;
-        int y = 99;
-        not_null<int*> nn{&x};
-        const not_null<int*> cnn{&x};
+    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;
+    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));
-    }
-
-    {
-        const int x = 42;
-        const int y = 99;
-        not_null<const int*> nn{&x};
-        const not_null<const int*> cnn{&x};
-
-        std::hash<not_null<const int*>> hash_nn;
-        std::hash<const 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));
-    }
-
-    {
-        auto x = std::make_shared<int>(42);
-        auto y = std::make_shared<int>(99);
-        not_null<std::shared_ptr<int>> nn{x};
-        const not_null<std::shared_ptr<int>> cnn{x};
-
-        std::hash<not_null<std::shared_ptr<int>>> hash_nn;
-        std::hash<std::shared_ptr<int>> hash_sharedptr;
-
-        EXPECT_TRUE(hash_nn(nn) == hash_sharedptr(x));
-        EXPECT_FALSE(hash_nn(nn) == hash_sharedptr(y));
-        EXPECT_TRUE(hash_nn(cnn) == hash_sharedptr(x));
-    }
+    EXPECT_TRUE(hash_nn(nn) == hash_intptr(&x));
+    EXPECT_FALSE(hash_nn(nn) == hash_intptr(&y));
+    EXPECT_FALSE(hash_nn(nn) == hash_intptr(nullptr));
 }

tests/owner_tests.cpp

@@ -17,11 +17,10 @@
 #include <gtest/gtest.h>
 
 #include <gsl/pointers> // for owner
-#include <type_traits>  // for declval
 
 using namespace gsl;
 
-GSL_SUPPRESS(f.23)
+GSL_SUPPRESS(f .23) // NO-FORMAT: attribute
 void f(int* i) { *i += 1; }
 
 TEST(owner_tests, basic_test)
@@ -33,17 +32,12 @@ TEST(owner_tests, basic_test)
     delete p;
 }
 
-#if __cplusplus >= 201703l
-using std::void_t;
-#else  // __cplusplus >= 201703l
-template <class...>
-using void_t = void;
-#endif // __cplusplus < 201703l
-
-template <typename U, typename = void>
-static constexpr bool OwnerCompilesFor = false;
-template <typename U>
-static constexpr bool OwnerCompilesFor<U, void_t<decltype(gsl::owner<U>{})>> = true;
-static_assert(OwnerCompilesFor<int*>, "OwnerCompilesFor<int*>");
-static_assert(!OwnerCompilesFor<int>, "!OwnerCompilesFor<int>");
-static_assert(!OwnerCompilesFor<std::shared_ptr<int>>, "!OwnerCompilesFor<std::shared_ptr<int>>");
+TEST(owner_tests, check_pointer_constraint)
+{
+#ifdef CONFIRM_COMPILATION_ERRORS
+    {
+        owner<int> integerTest = 10;
+        owner<std::shared_ptr<int>> sharedPtrTest(new int(10));
+    }
+#endif
+}

tests/pointers_tests.cpp

@@ -1,119 +0,0 @@
-#include <gtest/gtest.h>
-
-#include <gsl/pointers>
-
-#include <functional>
-#include <memory>
-#include <type_traits>
-#include <utility>
-
-#if __cplusplus >= 201703l
-using std::void_t;
-#else  // __cplusplus >= 201703l
-template <class...>
-using void_t = void;
-#endif // __cplusplus < 201703l
-
-namespace
-{
-// Custom pointer type that can be used for gsl::not_null, but for which these cannot be swapped.
-struct NotMoveAssignableCustomPtr
-{
-    NotMoveAssignableCustomPtr() = default;
-    NotMoveAssignableCustomPtr(const NotMoveAssignableCustomPtr&) = default;
-    NotMoveAssignableCustomPtr& operator=(const NotMoveAssignableCustomPtr&) = default;
-    NotMoveAssignableCustomPtr(NotMoveAssignableCustomPtr&&) = default;
-    NotMoveAssignableCustomPtr& operator=(NotMoveAssignableCustomPtr&&) = delete;
-
-    bool operator!=(std::nullptr_t) const { return true; }
-
-    int dummy{}; // Without this clang warns, that NotMoveAssignableCustomPtr() is unneeded
-};
-
-template <typename U, typename = void>
-static constexpr bool SwapCompilesFor = false;
-template <typename U>
-static constexpr bool
-    SwapCompilesFor<U, void_t<decltype(gsl::swap<U>(std::declval<gsl::not_null<U>&>(),
-                                                    std::declval<gsl::not_null<U>&>()))>> = true;
-
-TEST(pointers_test, swap)
-{
-    // taken from gh-1129:
-    {
-        gsl::not_null<std::unique_ptr<int>> a(std::make_unique<int>(0));
-        gsl::not_null<std::unique_ptr<int>> b(std::make_unique<int>(1));
-
-        static_assert(noexcept(gsl::swap(a, b)),
-                      "not null unique_ptr should be noexcept-swappable");
-
-        EXPECT_TRUE(*a == 0);
-        EXPECT_TRUE(*b == 1);
-
-        gsl::swap(a, b);
-
-        EXPECT_TRUE(*a == 1);
-        EXPECT_TRUE(*b == 0);
-
-        // Make sure our custom ptr can be used with not_null. The shared_pr is to prevent "unused"
-        // compiler warnings.
-        const auto shared_custom_ptr{std::make_shared<NotMoveAssignableCustomPtr>()};
-        gsl::not_null<NotMoveAssignableCustomPtr> c{*shared_custom_ptr};
-        EXPECT_TRUE(c.get() != nullptr);
-    }
-
-    {
-        gsl::strict_not_null<std::unique_ptr<int>> a{std::make_unique<int>(0)};
-        gsl::strict_not_null<std::unique_ptr<int>> b{std::make_unique<int>(1)};
-
-        static_assert(noexcept(gsl::swap(a, b)),
-                      "strict not null unique_ptr should be noexcept-swappable");
-
-        EXPECT_TRUE(*a == 0);
-        EXPECT_TRUE(*b == 1);
-
-        gsl::swap(a, b);
-
-        EXPECT_TRUE(*a == 1);
-        EXPECT_TRUE(*b == 0);
-    }
-
-    {
-        gsl::not_null<std::unique_ptr<int>> a{std::make_unique<int>(0)};
-        gsl::strict_not_null<std::unique_ptr<int>> b{std::make_unique<int>(1)};
-
-        EXPECT_TRUE(*a == 0);
-        EXPECT_TRUE(*b == 1);
-
-        gsl::swap(a, b);
-
-        EXPECT_TRUE(*a == 1);
-        EXPECT_TRUE(*b == 0);
-    }
-
-    static_assert(!SwapCompilesFor<NotMoveAssignableCustomPtr>,
-                  "!SwapCompilesFor<NotMoveAssignableCustomPtr>");
-}
-
-TEST(pointers_test, member_types)
-{
-    static_assert(std::is_same<gsl::not_null<int*>::element_type, int*>::value,
-                  "check member type: element_type");
-}
-
-TEST(pointers_test, hash_noexcept_compiles)
-{
-    {
-        using Key = gsl::not_null<std::shared_ptr<int>>;
-        static_assert(noexcept(std::hash<Key>{}(std::declval<Key>())),
-                      "gsl::not_null hash operator must be noexcept");
-    }
-
-    {
-        using Key = gsl::strict_not_null<std::shared_ptr<int>>;
-        static_assert(noexcept(std::hash<Key>{}(std::declval<Key>())),
-                      "gsl::strict_not_null hash operator must be noexcept");
-    }
-}
-
-} // namespace

tests/span_compatibility_tests.cpp

@@ -61,10 +61,10 @@ void ArrayConvertibilityCheck()
 
         static_assert(std::is_same<decltype(gsl::span{stl_nullptr}), gsl::span<T*, 3>>::value,
                       "std::is_same< decltype(span{stl_nullptr}), span<T*, 3>>::value");
-        static_assert(std::is_same<decltype(gsl::span{std::as_const(stl_nullptr)}),
-                                   gsl::span<T* const, 3>>::value,
-                      "std::is_same< decltype(span{std::as_const(stl_nullptr)}), span<T* const, "
-                      "3>>::value");
+        static_assert(
+            std::is_same<decltype(gsl::span{std::as_const(stl_nullptr)}), gsl::span<T* const, 3>>::value,
+            "std::is_same< decltype(span{std::as_const(stl_nullptr)}), span<T* const, "
+            "3>>::value");
     }
 #endif
 }
@@ -519,7 +519,7 @@ TEST(span_compatibility_tests, assertion_tests)
 
 // assertions for span's definition
 static_assert(std::is_same<decltype(gsl::dynamic_extent), const std::size_t>::value,
-              "gsl::dynamic_extent must be represented as std::size_t");
+              "gsl::dynamic_extent must be respresented as std::size_t");
 static_assert(gsl::dynamic_extent == static_cast<std::size_t>(-1),
               "gsl::dynamic_extent must be defined as the max value of std::size_t");
 
@@ -1005,18 +1005,12 @@ static_assert(std::is_convertible<const std::array<int, 3>&, gsl::span<const int
               "std::is_convertible<const std::array<int, 3>&, gsl::span<const int>>");
 
 #if __cplusplus >= 201703l
-using std::void_t;
-#else  // __cplusplus >= 201703l
-template <class...>
-using void_t = void;
-#endif // __cplusplus < 201703l
-
 template <typename U, typename = void>
 static constexpr bool AsWritableBytesCompilesFor = false;
 
 template <typename U>
 static constexpr bool
-    AsWritableBytesCompilesFor<U, ::void_t<decltype(as_writable_bytes(declval<U>()))>> = true;
+    AsWritableBytesCompilesFor<U, void_t<decltype(as_writable_bytes(declval<U>()))>> = true;
 
 static_assert(AsWritableBytesCompilesFor<gsl::span<int>>,
               "AsWritableBytesCompilesFor<gsl::span<int>>");
@@ -1026,3 +1020,4 @@ static_assert(!AsWritableBytesCompilesFor<gsl::span<const int>>,
               "!AsWritableBytesCompilesFor<gsl::span<const int>>");
 static_assert(!AsWritableBytesCompilesFor<gsl::span<const int, 9>>,
               "!AsWritableBytesCompilesFor<gsl::span<const int, 9>>");
+#endif // __cplusplus >= 201703l

tests/span_ext_tests.cpp

@@ -19,10 +19,9 @@
 #include <gsl/span> // for span and span_ext
 #include <gsl/util> // for narrow_cast, at
 
-#include <array>     // for array
-#include <exception> // for terminate
-#include <iostream>  // for cerr
-#include <vector>    // for vector
+#include <array>    // for array
+#include <iostream> // for cerr
+#include <vector>   // for vector
 
 using namespace std;
 using namespace gsl;
@@ -114,7 +113,7 @@ TEST(span_ext_test, make_span_from_array_constructor)
 
 TEST(span_ext_test, make_span_from_dynamic_array_constructor)
 {
-    double (*arr)[3][4] = new double[100][3][4];
+    double(*arr)[3][4] = new double[100][3][4];
 
     {
         auto s = make_span(&arr[0][0][0], 10);
@@ -194,28 +193,10 @@ TEST(span_ext_test, make_span_from_container_constructor)
 
 TEST(span_test, interop_with_gsl_at)
 {
-    std::vector<int> vec{1, 2, 3, 4, 5};
-    gsl::span<int> sp{vec};
-
-    std::vector<int> cvec{1, 2, 3, 4, 5};
-    gsl::span<int> csp{cvec};
-
-    for (gsl::index i = 0; i < gsl::narrow_cast<gsl::index>(vec.size()); ++i)
-    {
-        EXPECT_TRUE(&gsl::at(sp, i) == &vec[gsl::narrow_cast<size_t>(i)]);
-        EXPECT_TRUE(&gsl::at(csp, i) == &cvec[gsl::narrow_cast<size_t>(i)]);
-    }
-
-    const auto terminateHandler = std::set_terminate([] {
-        std::cerr << "Expected Death. interop_with_gsl_at";
-        std::abort();
-    });
-    const auto expected = GetExpectedDeathString(terminateHandler);
-
-    EXPECT_DEATH(gsl::at(sp, -1), expected);
-    EXPECT_DEATH(gsl::at(sp, gsl::narrow_cast<gsl::index>(sp.size())), expected);
-    EXPECT_DEATH(gsl::at(csp, -1), expected);
-    EXPECT_DEATH(gsl::at(csp, gsl::narrow_cast<gsl::index>(sp.size())), expected);
+    int arr[5] = {1, 2, 3, 4, 5};
+    gsl::span<int> s{arr};
+    EXPECT_TRUE(at(s, 0) == 1);
+    EXPECT_TRUE(at(s, 1) == 2);
 }
 
 TEST(span_ext_test, iterator_free_functions)

tests/span_tests.cpp

@@ -32,14 +32,14 @@
 #include <vector> // for vector
 
 // the string_view include and macro are used in the deduction guide verification
-#if defined(__cpp_deduction_guides) && (__cpp_deduction_guides >= 201703L)
+#if (defined(__cpp_deduction_guides) && (__cpp_deduction_guides >= 201611L))
 #ifdef __has_include
 #if __has_include(<string_view>)
 #include <string_view>
 #define HAS_STRING_VIEW
 #endif // __has_include(<string_view>)
 #endif // __has_include
-#endif // defined(__cpp_deduction_guides) && (__cpp_deduction_guides >= 201703L)
+#endif // (defined(__cpp_deduction_guides) && (__cpp_deduction_guides >= 201611L))
 #if defined(__cplusplus) && __cplusplus >= 202002L
 #include <span>
 #endif // __cplusplus >= 202002L
@@ -48,13 +48,6 @@
 
 using namespace gsl;
 
-#if __cplusplus >= 201703l
-using std::void_t;
-#else  // __cplusplus >= 201703l
-template <class...>
-using void_t = void;
-#endif // __cplusplus < 201703l
-
 namespace
 {
 
@@ -69,7 +62,8 @@ struct AddressOverloaded
 #if (__cplusplus > 201402L)
     [[maybe_unused]]
 #endif
-    AddressOverloaded operator&() const
+    AddressOverloaded
+    operator&() const
     {
         return {};
     }
@@ -222,12 +216,6 @@ TEST(span_test, from_pointer_length_constructor)
 
 TEST(span_test, from_pointer_pointer_construction)
 {
-    // const auto terminateHandler = std::set_terminate([] {
-    //     std::cerr << "Expected Death. from_pointer_pointer_construction";
-    //     std::abort();
-    // });
-    // const auto expected = GetExpectedDeathString(terminateHandler);
-
     int arr[4] = {1, 2, 3, 4};
 
     {
@@ -257,13 +245,19 @@ TEST(span_test, from_pointer_pointer_construction)
         EXPECT_TRUE(s.data() == &arr[0]);
     }
 
-    // this test succeeds on all platforms, gsl::span is more relaxed than std::span where this
-    // would be UB
+    // this will fail the std::distance() precondition, which asserts on MSVC debug builds
     //{
     //    auto workaround_macro = [&]() { span<int> s{&arr[1], &arr[0]}; };
     //    EXPECT_DEATH(workaround_macro(), expected);
     //}
 
+    // this will fail the std::distance() precondition, which asserts on MSVC debug builds
+    //{
+    //    int* p = nullptr;
+    //    auto workaround_macro = [&]() { span<int> s{&arr[0], p}; };
+    //    EXPECT_DEATH(workaround_macro(), expected);
+    //}
+
     {
         int* p = nullptr;
         span<int> s{p, p};
@@ -277,21 +271,19 @@ TEST(span_test, from_pointer_pointer_construction)
         EXPECT_TRUE(s.size() == 0);
         EXPECT_TRUE(s.data() == nullptr);
     }
-}
 
-template <typename U, typename V, typename = void>
-static constexpr bool CtorCompilesFor = false;
-template <typename U, typename V>
-static constexpr bool CtorCompilesFor<U, V, void_t<decltype(U{std::declval<V>()})>> = true;
+    // this will fail the std::distance() precondition, which asserts on MSVC debug builds
+    //{
+    //    int* p = nullptr;
+    //    auto workaround_macro = [&]() { span<int> s{&arr[0], p}; };
+    //    EXPECT_DEATH(workaround_macro(), expected);
+    //}
+}
 
 TEST(span_test, from_array_constructor)
 {
     int arr[5] = {1, 2, 3, 4, 5};
 
-    static_assert(!CtorCompilesFor<span<int, 6>, int[5]>, "!CtorCompilesFor<span<int, 6>, int[5]>");
-    static_assert(!CtorCompilesFor<span<int, 0>, int[5]>, "!CtorCompilesFor<span<int, 0>, int[5]>");
-    static_assert(!CtorCompilesFor<span<int>, int[2][3]>, "!CtorCompilesFor<span<int>, int[2][3]>");
-
     {
         const span<int> s{arr};
         EXPECT_TRUE(s.size() == 5);
@@ -306,28 +298,70 @@ TEST(span_test, from_array_constructor)
 
     int arr2d[2][3] = {1, 2, 3, 4, 5, 6};
 
-    static_assert(!CtorCompilesFor<span<int, 0>, int[2][3]>,
-                  "!CtorCompilesFor<span<int, 0>, int[2][3]>");
-    static_assert(!CtorCompilesFor<span<int, 6>, int[2][3]>,
-                  "!CtorCompilesFor<span<int, 6>, int[2][3]>");
+#ifdef CONFIRM_COMPILATION_ERRORS
+    {
+        span<int, 6> s{arr};
+    }
 
+    {
+        span<int, 0> s{arr};
+        EXPECT_TRUE(s.size() == 0);
+        EXPECT_TRUE(s.data() == &arr[0]);
+    }
+
+    {
+        span<int> s{arr2d};
+        EXPECT_TRUE(s.size() == 6);
+        EXPECT_TRUE(s.data() == &arr2d[0][0]);
+        EXPECT_TRUE(s[0] == 1);
+        EXPECT_TRUE(s[5] == 6);
+    }
+
+    {
+        span<int, 0> s{arr2d};
+        EXPECT_TRUE(s.size() == 0);
+        EXPECT_TRUE(s.data() == &arr2d[0][0]);
+    }
+
+    {
+        span<int, 6> s{arr2d};
+    }
+#endif
     {
         const span<int[3]> s{std::addressof(arr2d[0]), 1};
         EXPECT_TRUE(s.size() == 1);
         EXPECT_TRUE(s.data() == std::addressof(arr2d[0]));
     }
 
-    int arr3d[2][3][2] = {{{1, 2}, {3, 4}, {5, 6}}, {{7, 8}, {9, 10}, {11, 12}}};
+    int arr3d[2][3][2] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
 
-    static_assert(!CtorCompilesFor<span<int>, int[2][3][2]>,
-                  "!CtorCompilesFor<span<int>, int[2][3][2]>");
-    static_assert(!CtorCompilesFor<span<int, 0>, int[2][3][2]>,
-                  "!CtorCompilesFor<span<int, 0>, int[2][3][2]>");
-    static_assert(!CtorCompilesFor<span<int, 11>, int[2][3][2]>,
-                  "!CtorCompilesFor<span<int, 11>, int[2][3][2]>");
-    static_assert(!CtorCompilesFor<span<int, 12>, int[2][3][2]>,
-                  "!CtorCompilesFor<span<int, 12>, int[2][3][2]>");
+#ifdef CONFIRM_COMPILATION_ERRORS
+    {
+        span<int> s{arr3d};
+        EXPECT_TRUE(s.size() == 12);
+        EXPECT_TRUE(s.data() == &arr3d[0][0][0]);
+        EXPECT_TRUE(s[0] == 1);
+        EXPECT_TRUE(s[11] == 12);
+    }
 
+    {
+        span<int, 0> s{arr3d};
+        EXPECT_TRUE(s.size() == 0);
+        EXPECT_TRUE(s.data() == &arr3d[0][0][0]);
+    }
+
+    {
+        span<int, 11> s{arr3d};
+    }
+
+    {
+        span<int, 12> s{arr3d};
+        EXPECT_TRUE(s.size() == 12);
+        EXPECT_TRUE(s.data() == &arr3d[0][0][0]);
+        EXPECT_TRUE(s[0] == 1);
+        EXPECT_TRUE(s[5] == 6);
+    }
+#endif
     {
         const span<int[3][2]> s{std::addressof(arr3d[0]), 1};
         EXPECT_TRUE(s.size() == 1);
@@ -344,7 +378,7 @@ TEST(span_test, from_array_constructor)
 
 TEST(span_test, from_dynamic_array_constructor)
 {
-    double (*arr)[3][4] = new double[100][3][4];
+    double(*arr)[3][4] = new double[100][3][4];
 
     {
         span<double> s(&arr[0][0][0], 10);
@@ -355,13 +389,6 @@ TEST(span_test, from_dynamic_array_constructor)
     delete[] arr;
 }
 
-template <typename U, typename V, typename = void>
-static constexpr bool ConversionCompilesFor = false;
-template <typename U, typename V>
-static constexpr bool
-    ConversionCompilesFor<U, V, void_t<decltype(std::declval<void (*)(U)>()(std::declval<V>()))>> =
-        true;
-
 TEST(span_test, from_std_array_constructor)
 {
     std::array<int, 4> arr = {1, 2, 3, 4};
@@ -401,31 +428,43 @@ TEST(span_test, from_std_array_constructor)
         EXPECT_TRUE(ao_arr.data() == fs.data());
     }
 
-    static_assert(!CtorCompilesFor<span<int, 2>, std::array<int, 4>&>,
-                  "!CtorCompilesFor<span<int, 2>, std::array<int, 4>&>");
-    static_assert(!CtorCompilesFor<span<const int, 2>, std::array<int, 4>&>,
-                  "!CtorCompilesFor<span<const int, 2>, std::array<int, 4>&>");
+#ifdef CONFIRM_COMPILATION_ERRORS
+    {
+        span<int, 2> s{arr};
+        EXPECT_TRUE(s.size() == 2);
+        EXPECT_TRUE(s.data() == arr.data());
 
-    static_assert(!CtorCompilesFor<span<int, 0>, std::array<int, 4>&>,
-                  "!CtorCompilesFor<span<int, 0>, std::array<int, 4>&>");
-    static_assert(!CtorCompilesFor<span<const int, 0>, std::array<int, 4>&>,
-                  "!CtorCompilesFor<span<const int, 0>, std::array<int, 4>&>");
+        span<const int, 2> cs{arr};
+        EXPECT_TRUE(cs.size() == 2);
+        EXPECT_TRUE(cs.data() == arr.data());
+    }
 
-    static_assert(!CtorCompilesFor<span<int, 5>, std::array<int, 4>&>,
-                  "!CtorCompilesFor<span<int, 5>, std::array<int, 4>&>");
+    {
+        span<int, 0> s{arr};
+        EXPECT_TRUE(s.size() == 0);
+        EXPECT_TRUE(s.data() == arr.data());
 
-#if !defined(_MSC_VER) || (__cplusplus >= 201703L)
-    // Fails on MSVC. TODO: report a feedback bug.
-    static_assert(!ConversionCompilesFor<span<int>, std::array<int, 4>>,
-                  "!ConversionCompilesFor<span<int>, std::array<int, 4>>");
+        span<const int, 0> cs{arr};
+        EXPECT_TRUE(cs.size() == 0);
+        EXPECT_TRUE(cs.data() == arr.data());
+    }
+
+    {
+        span<int, 5> s{arr};
+    }
+
+    {
+        auto get_an_array = []() -> std::array<int, 4> { return {1, 2, 3, 4}; };
+        auto take_a_span = [](span<int> s) { static_cast<void>(s); };
+        // try to take a temporary std::array
+        take_a_span(get_an_array());
+    }
 #endif
 
     {
         auto get_an_array = []() -> std::array<int, 4> { return {1, 2, 3, 4}; };
-        auto take_a_span = [](span<const int>) {};
+        auto take_a_span = [](span<const int> s) { static_cast<void>(s); };
         // try to take a temporary std::array
-        static_assert(ConversionCompilesFor<span<const int>, std::array<int, 4>>,
-                      "ConversionCompilesFor<span<const int>, std::array<int, 4>>");
         take_a_span(get_an_array());
     }
 }
@@ -454,12 +493,23 @@ TEST(span_test, from_const_std_array_constructor)
         EXPECT_TRUE(s.data() == ao_arr.data());
     }
 
-    static_assert(!CtorCompilesFor<span<const int, 2>, std::array<int, 4>&>,
-                  "!CtorCompilesFor<span<const int, 2>, std::array<int, 4>&>");
-    static_assert(!CtorCompilesFor<span<const int, 0>, std::array<int, 4>&>,
-                  "!CtorCompilesFor<span<const int, 0>, std::array<int, 4>&>");
-    static_assert(!CtorCompilesFor<span<int, 5>, std::array<int, 4>&>,
-                  "!CtorCompilesFor<span<int, 5>, std::array<int, 4>&>");
+#ifdef CONFIRM_COMPILATION_ERRORS
+    {
+        span<const int, 2> s{arr};
+        EXPECT_TRUE(s.size() == 2);
+        EXPECT_TRUE(s.data() == arr.data());
+    }
+
+    {
+        span<const int, 0> s{arr};
+        EXPECT_TRUE(s.size() == 0);
+        EXPECT_TRUE(s.data() == arr.data());
+    }
+
+    {
+        span<const int, 5> s{arr};
+    }
+#endif
 
     {
         auto get_an_array = []() -> const std::array<int, 4> { return {1, 2, 3, 4}; };
@@ -485,14 +535,27 @@ TEST(span_test, from_std_array_const_constructor)
         EXPECT_TRUE(s.data() == arr.data());
     }
 
-    static_assert(!CtorCompilesFor<span<const int, 2>, const std::array<int, 4>&>,
-                  "!CtorCompilesFor<span<const int, 2>, const std::array<int, 4>&>");
-    static_assert(!CtorCompilesFor<span<const int, 0>, const std::array<int, 4>&>,
-                  "!CtorCompilesFor<span<const int, 0>, const std::array<int, 4>&>");
-    static_assert(!CtorCompilesFor<span<const int, 5>, const std::array<int, 4>&>,
-                  "!CtorCompilesFor<span<const int, 5>, const std::array<int, 4>&>");
-    static_assert(!CtorCompilesFor<span<int, 5>, const std::array<int, 4>&>,
-                  "!CtorCompilesFor<span<int, 5>, const std::array<int, 4>&>");
+#ifdef CONFIRM_COMPILATION_ERRORS
+    {
+        span<const int, 2> s{arr};
+        EXPECT_TRUE(s.size() == 2);
+        EXPECT_TRUE(s.data() == arr.data());
+    }
+
+    {
+        span<const int, 0> s{arr};
+        EXPECT_TRUE(s.size() == 0);
+        EXPECT_TRUE(s.data() == arr.data());
+    }
+
+    {
+        span<const int, 5> s{arr};
+    }
+
+    {
+        span<int, 4> s{arr};
+    }
+#endif
 }
 
 TEST(span_test, from_container_constructor)
@@ -514,28 +577,32 @@ TEST(span_test, from_container_constructor)
     const std::string cstr = "hello";
 
     {
-        static_assert(CtorCompilesFor<span<char>, std::string&> == (__cplusplus >= 201703L),
-                      "CtorCompilesFor<span<char>, std::string&> == (__cplusplus >= 201703L)");
-
-        span<const char> cs{str};
-        EXPECT_TRUE(cs.size() == str.size());
-        EXPECT_TRUE(cs.data() == str.data());
+#ifdef CONFIRM_COMPILATION_ERRORS
+        span<char> s{str};
+        EXPECT_TRUE(s.size() == str.size());
+         EXPECT_TRUE(s.data() == str.data()));
+#endif
+         span<const char> cs{str};
+         EXPECT_TRUE(cs.size() == str.size());
+         EXPECT_TRUE(cs.data() == str.data());
     }
 
     {
-        static_assert(!CtorCompilesFor<span<char>, const std::string&>,
-                      "!CtorCompilesFor<span<char>, const std::string&>");
-
+#ifdef CONFIRM_COMPILATION_ERRORS
+        span<char> s{cstr};
+#endif
         span<const char> cs{cstr};
         EXPECT_TRUE(cs.size() == cstr.size());
         EXPECT_TRUE(cs.data() == cstr.data());
     }
 
-#if !defined(_MSC_VER) || (__cplusplus >= 201703L)
-    // Fails on MSVC. TODO: report a feedback bug.
-    static_assert(!ConversionCompilesFor<span<int>, std::vector<int>>,
-                  "!ConversionCompilesFor<span<int>, std::vector<int>>");
-#endif // !defined(_MSC_VER) || (_MSC_VER > 1942) || (__cplusplus >= 201703L)
+    {
+#ifdef CONFIRM_COMPILATION_ERRORS
+        auto get_temp_vector = []() -> std::vector<int> { return {}; };
+        auto use_span = [](span<int> s) { static_cast<void>(s); };
+        use_span(get_temp_vector());
+#endif
+    }
 
     {
         auto get_temp_vector = []() -> std::vector<int> { return {}; };
@@ -543,8 +610,13 @@ TEST(span_test, from_container_constructor)
         use_span(get_temp_vector());
     }
 
-    static_assert(!ConversionCompilesFor<span<char>, std::string>,
-                  "!ConversionCompilesFor<span<char>, std::string>");
+    {
+#ifdef CONFIRM_COMPILATION_ERRORS
+        auto get_temp_string = []() -> std::string { return {}; };
+        auto use_span = [](span<char> s) { static_cast<void>(s); };
+        use_span(get_temp_string());
+#endif
+    }
 
     {
         auto get_temp_string = []() -> std::string { return {}; };
@@ -552,10 +624,13 @@ TEST(span_test, from_container_constructor)
         use_span(get_temp_string());
     }
 
-    static_assert(!ConversionCompilesFor<span<const char>, const std::vector<int>>,
-                  "!ConversionCompilesFor<span<const char>, const std::vector<int>>");
-    static_assert(!ConversionCompilesFor<span<char>, const std::string>,
-                  "!ConversionCompilesFor<span<char>, const std::string>");
+    {
+#ifdef CONFIRM_COMPILATION_ERRORS
+        auto get_temp_vector = []() -> const std::vector<int> { return {}; };
+        auto use_span = [](span<const char> s) { static_cast<void>(s); };
+        use_span(get_temp_vector());
+#endif
+    }
 
     {
         auto get_temp_string = []() -> const std::string { return {}; };
@@ -563,73 +638,46 @@ TEST(span_test, from_container_constructor)
         use_span(get_temp_string());
     }
 
-    static_assert(!CtorCompilesFor<span<int>, std::map<int, int>&>,
-                  "!CtorCompilesFor<span<int>, std::map<int, int>&>");
+    {
+#ifdef CONFIRM_COMPILATION_ERRORS
+        std::map<int, int> m;
+        span<int> s{m};
+#endif
+    }
+}
+
+TEST(span_test, from_convertible_span_constructor){{span<DerivedClass> avd;
+span<const DerivedClass> avcd = avd;
+static_cast<void>(avcd);
 }
 
-TEST(span_test, from_convertible_span_constructor)
 {
-    const auto terminateHandler = std::set_terminate([] {
-        std::cerr << "Expected Death. from_convertible_span_constructor";
-        std::abort();
-    });
-    const auto expected = GetExpectedDeathString(terminateHandler);
+#ifdef CONFIRM_COMPILATION_ERRORS
+    span<DerivedClass> avd;
+    span<BaseClass> avb = avd;
+    static_cast<void>(avb);
+#endif
+}
 
-    {
-        span<DerivedClass> avd;
-        span<const DerivedClass> avcd = avd;
-        static_cast<void>(avcd);
-    }
+#ifdef CONFIRM_COMPILATION_ERRORS
+{
+    span<int> s;
+    span<unsigned int> s2 = s;
+    static_cast<void>(s2);
+}
 
-    {
-        std::array<DerivedClass, 2> arr{};
-        span<DerivedClass, 2> avd{arr};
-        span<const DerivedClass, 2> avcd = avd;
-        static_cast<void>(avcd);
-    }
+{
+    span<int> s;
+    span<const unsigned int> s2 = s;
+    static_cast<void>(s2);
+}
 
-    {
-        std::array<DerivedClass, 2> arr{};
-        span<DerivedClass, 2> avd{arr};
-        span<const DerivedClass> avcd = avd;
-        static_cast<void>(avcd);
-    }
-
-    {
-        std::array<DerivedClass, 2> arr{};
-        span<DerivedClass> avd{arr};
-        span<const DerivedClass, 2> avcd{avd};
-        static_cast<void>(avcd);
-    }
-
-    {
-        std::array<DerivedClass, 2> arr{};
-        span<DerivedClass> avd{arr};
-        using T = span<const DerivedClass, 1>;
-        EXPECT_DEATH(T{avd}, expected);
-    }
-
-    {
-        std::array<DerivedClass, 1> arr{};
-        span<DerivedClass> avd{arr};
-        using T = span<const DerivedClass, 2>;
-        EXPECT_DEATH(T{avd}, expected);
-    }
-
-    static_assert(!ConversionCompilesFor<span<const DerivedClass, 2>, span<DerivedClass>&>,
-                  "!ConversionCompilesFor<span<const DerivedClass, 2>, span<DerivedClass>&>");
-    static_assert(!ConversionCompilesFor<span<const DerivedClass, 1>, span<DerivedClass, 2>&>,
-                  "!ConversionCompilesFor<span<const DerivedClass, 1>, span<DerivedClass, 2>&>");
-    static_assert(!ConversionCompilesFor<span<const DerivedClass, 3>, span<DerivedClass, 2>&>,
-                  "!ConversionCompilesFor<span<const DerivedClass, 3>, span<DerivedClass, 2>&>");
-    static_assert(!ConversionCompilesFor<span<BaseClass, 3>, span<DerivedClass>&>,
-                  "!ConversionCompilesFor<span<BaseClass, 3>, span<DerivedClass>&>");
-    static_assert(!ConversionCompilesFor<span<unsigned int>, span<int>&>,
-                  "!ConversionCompilesFor<span<unsigned int>, span<int>&>");
-    static_assert(!ConversionCompilesFor<span<const unsigned int>, span<int>&>,
-                  "!ConversionCompilesFor<span<const unsigned int>, span<int>&>");
-    static_assert(!ConversionCompilesFor<span<short>, span<int>&>,
-                  "!ConversionCompilesFor<span<short>, span<int>&>");
+{
+    span<int> s;
+    span<short> s2 = s;
+    static_cast<void>(s2);
+}
+#endif
 }
 
 TEST(span_test, copy_move_and_assignment)
@@ -689,9 +737,10 @@ TEST(span_test, first)
     {
         span<int, 5> av = arr;
 #ifdef CONFIRM_COMPILATION_ERRORS
-        (void) av.first<6>();
+        EXPECT_TRUE(av.first<6>().size() == 6);
+        EXPECT_TRUE(av.first<-1>().size() == -1);
 #endif
-        EXPECT_DEATH(av.first(6), expected);
+        EXPECT_DEATH(av.first(6).size(), expected);
     }
 
     {
@@ -732,9 +781,9 @@ TEST(span_test, last)
     {
         span<int, 5> av = arr;
 #ifdef CONFIRM_COMPILATION_ERRORS
-        (void) av.last<6>();
+        EXPECT_TRUE(av.last<6>().size() == 6);
 #endif
-        EXPECT_DEATH(av.last(6), expected);
+        EXPECT_DEATH(av.last(6).size(), expected);
     }
 
     {
@@ -759,9 +808,6 @@ TEST(span_test, subspan)
         EXPECT_TRUE((av.subspan<2, 2>().size()) == 2);
         EXPECT_TRUE(decltype(av.subspan<2, 2>())::extent == 2);
         EXPECT_TRUE(av.subspan(2, 2).size() == 2);
-
-        EXPECT_TRUE((av.subspan<2, 3>().size()) == 3);
-        EXPECT_TRUE(decltype(av.subspan<2, 3>())::extent == 3);
         EXPECT_TRUE(av.subspan(2, 3).size() == 3);
     }
 
@@ -778,12 +824,8 @@ TEST(span_test, subspan)
         EXPECT_TRUE(decltype(av.subspan<0, 5>())::extent == 5);
         EXPECT_TRUE(av.subspan(0, 5).size() == 5);
 
-#ifdef CONFIRM_COMPILATION_ERRORS
-        (void) av.subspan<0, 6>();
-        (void) av.subspan<1, 5>();
-#endif
-        EXPECT_DEATH(av.subspan(0, 6), expected);
-        EXPECT_DEATH(av.subspan(1, 5), expected);
+        EXPECT_DEATH(av.subspan(0, 6).size(), expected);
+        EXPECT_DEATH(av.subspan(1, 5).size(), expected);
     }
 
     {
@@ -791,22 +833,14 @@ TEST(span_test, subspan)
         EXPECT_TRUE((av.subspan<4, 0>().size()) == 0);
         EXPECT_TRUE(decltype(av.subspan<4, 0>())::extent == 0);
         EXPECT_TRUE(av.subspan(4, 0).size() == 0);
-
-        EXPECT_TRUE((av.subspan<5, 0>().size()) == 0);
-        EXPECT_TRUE(decltype(av.subspan<5, 0>())::extent == 0);
         EXPECT_TRUE(av.subspan(5, 0).size() == 0);
-
-#ifdef CONFIRM_COMPILATION_ERRORS
-        (void) av.subspan<6, 0>();
-#endif
-        EXPECT_DEATH(av.subspan(6, 0), expected);
+        EXPECT_DEATH(av.subspan(6, 0).size(), expected);
     }
 
     {
         span<int, 5> av = arr;
         EXPECT_TRUE(av.subspan<1>().size() == 4);
         EXPECT_TRUE(decltype(av.subspan<1>())::extent == 4);
-        EXPECT_TRUE(av.subspan(1).size() == 4);
     }
 
     {
@@ -814,58 +848,35 @@ TEST(span_test, subspan)
         EXPECT_TRUE((av.subspan<0, 0>().size()) == 0);
         EXPECT_TRUE(decltype(av.subspan<0, 0>())::extent == 0);
         EXPECT_TRUE(av.subspan(0, 0).size() == 0);
-
-        EXPECT_DEATH((av.subspan<1, 0>()), expected);
-        EXPECT_DEATH((av.subspan(1, 0)), expected);
+        EXPECT_DEATH((av.subspan<1, 0>().size()), expected);
     }
 
     {
         span<int> av;
-        EXPECT_TRUE((av.subspan<0>().size()) == 0);
-        EXPECT_TRUE(decltype(av.subspan<0>())::extent == dynamic_extent);
         EXPECT_TRUE(av.subspan(0).size() == 0);
-
-        EXPECT_DEATH(av.subspan<1>(), expected);
-        EXPECT_TRUE(decltype(av.subspan<1>())::extent == dynamic_extent);
-        EXPECT_DEATH(av.subspan(1), expected);
+        EXPECT_DEATH(av.subspan(1).size(), expected);
     }
 
     {
         span<int> av = arr;
         EXPECT_TRUE(av.subspan(0).size() == 5);
-        EXPECT_TRUE(av.subspan<0>().size() == 5);
         EXPECT_TRUE(av.subspan(1).size() == 4);
-        EXPECT_TRUE(av.subspan<1>().size() == 4);
         EXPECT_TRUE(av.subspan(4).size() == 1);
-        EXPECT_TRUE(av.subspan<4>().size() == 1);
         EXPECT_TRUE(av.subspan(5).size() == 0);
-        EXPECT_TRUE(av.subspan<5>().size() == 0);
-        EXPECT_DEATH(av.subspan(6), expected);
-        EXPECT_DEATH(av.subspan<6>(), expected);
+        EXPECT_DEATH(av.subspan(6).size(), expected);
         const auto av2 = av.subspan(1);
         for (std::size_t i = 0; i < 4; ++i) EXPECT_TRUE(av2[i] == static_cast<int>(i) + 2);
-        const auto av3 = av.subspan<1>();
-        for (std::size_t i = 0; i < 4; ++i) EXPECT_TRUE(av3[i] == static_cast<int>(i) + 2);
     }
 
     {
         span<int, 5> av = arr;
         EXPECT_TRUE(av.subspan(0).size() == 5);
-        EXPECT_TRUE(av.subspan<0>().size() == 5);
         EXPECT_TRUE(av.subspan(1).size() == 4);
-        EXPECT_TRUE(av.subspan<1>().size() == 4);
         EXPECT_TRUE(av.subspan(4).size() == 1);
-        EXPECT_TRUE(av.subspan<4>().size() == 1);
         EXPECT_TRUE(av.subspan(5).size() == 0);
-        EXPECT_TRUE(av.subspan<5>().size() == 0);
-        EXPECT_DEATH(av.subspan(6), expected);
-#ifdef CONFIRM_COMPILATION_ERRORS
-        EXPECT_DEATH(av.subspan<6>(), expected);
-#endif
+        EXPECT_DEATH(av.subspan(6).size(), expected);
         const auto av2 = av.subspan(1);
         for (std::size_t i = 0; i < 4; ++i) EXPECT_TRUE(av2[i] == static_cast<int>(i) + 2);
-        const auto av3 = av.subspan<1>();
-        for (std::size_t i = 0; i < 4; ++i) EXPECT_TRUE(av3[i] == static_cast<int>(i) + 2);
     }
 }
 
@@ -1040,21 +1051,15 @@ TEST(span_test, rbegin_rend)
     }
 }
 
-template <typename U, typename = void>
-static constexpr bool AsWritableBytesCompilesFor = false;
-template <typename U>
-static constexpr bool
-    AsWritableBytesCompilesFor<U, void_t<decltype(as_writable_bytes(std::declval<U>()))>> = true;
-
 TEST(span_test, as_bytes)
 {
+    const auto terminateHandler = std::set_terminate([] {
+        std::cerr << "Expected Death. as_bytes";
+        std::abort();
+    });
+    const auto expected = GetExpectedDeathString(terminateHandler);
+
     int a[] = {1, 2, 3, 4};
-
-    static_assert(AsWritableBytesCompilesFor<span<int>>, "AsWriteableBytesCompilesFor<span<int>>");
-    // you should not be able to get writeable bytes for const objects
-    static_assert(!AsWritableBytesCompilesFor<span<const int>>,
-                  "!AsWriteableBytesCompilesFor<span<const int>>");
-
     {
         const span<const int> s = a;
         EXPECT_TRUE(s.size() == 4);
@@ -1079,12 +1084,29 @@ TEST(span_test, as_bytes)
         EXPECT_TRUE(static_cast<const void*>(bs.data()) == static_cast<const void*>(s.data()));
         EXPECT_TRUE(bs.size() == s.size_bytes());
     }
+
+    int b[5] = {1, 2, 3, 4, 5};
+    {
+        span<int> sp(std::begin(b), static_cast<size_t>(-2));
+        EXPECT_DEATH((void) sp.size_bytes(), expected);
+    }
 }
 
 TEST(span_test, as_writable_bytes)
 {
     int a[] = {1, 2, 3, 4};
 
+    {
+#ifdef CONFIRM_COMPILATION_ERRORS
+        // you should not be able to get writeable bytes for const objects
+        span<const int> s = a;
+        EXPECT_TRUE(s.size() == 4);
+        span<const byte> bs = as_writable_bytes(s);
+        EXPECT_TRUE(static_cast<void*>(bs.data()) == static_cast<void*>(s.data()));
+        EXPECT_TRUE(bs.size() == s.size_bytes());
+#endif
+    }
+
     {
         span<int> s;
         const auto bs = as_writable_bytes(s);
@@ -1124,15 +1146,30 @@ TEST(span_test, fixed_size_conversions)
         static_cast<void>(s);
     }
 
-    // initialization or assignment to static span that REDUCES size is NOT ok
-    static_assert(!ConversionCompilesFor<span<int, 2>, int[4]>,
-                  "!ConversionCompilesFor<span<int, 2>, int[4]>");
-    static_assert(!ConversionCompilesFor<span<int, 2>, span<int, 4>>,
-                  "!ConversionCompilesFor<span<int, 2>, span<int, 4>>");
+// initialization or assignment to static span that REDUCES size is NOT ok
+#ifdef CONFIRM_COMPILATION_ERRORS
+    {
+        span<int, 2> s = arr;
+    }
+    {
+        span<int, 2> s2 = s4;
+        static_cast<void>(s2);
+    }
+#endif
 
     // even when done dynamically
-    static_assert(!ConversionCompilesFor<span<int, 2>, span<int>>,
-                  "!ConversionCompilesFor<span<int, 2>, span<int>>");
+    {
+        /*
+        // this now results in a compile-time error, rather than runtime.
+        // There is no suitable conversion from dynamic span to fixed span.
+        span<int> s = arr;
+        auto f = [&]() {
+            const span<int, 2> s2 = s;
+            static_cast<void>(s2);
+        };
+        EXPECT_DEATH(f(), expected);
+        */
+    }
 
     // but doing so explicitly is ok
 
@@ -1146,24 +1183,32 @@ TEST(span_test, fixed_size_conversions)
         static_cast<void>(s1);
     }
 
-    // this is not a legal operation in std::span, so we are no longer supporting it
-    // conversion from span<int, 4> to span<int, dynamic_extent> via call to `first`
-    // then convert from span<int, dynamic_extent> to span<int, 1>
-    // The dynamic to fixed extents are not supported in the standard
-    // to make this work, span<int, 1> would need to be span<int>.
-    static_assert(!ConversionCompilesFor<span<int, 1>, span<int>>,
-                  "!ConversionCompilesFor<span<int, 1>, span<int>>");
+    /*
+     // this is not a legal operation in std::span, so we are no longer supporting it
+     // conversion from span<int, 4> to span<int, dynamic_extent> via call to `first`
+     // then convert from span<int, dynamic_extent> to span<int, 1>
+     // The dynamic to fixed extents are not supported in the standard
+     // to make this work, span<int, 1> would need to be span<int>.
+     {
+
+         // NB: implicit conversion to span<int,1> from span<int>
+         span<int, 1> s1 = s4.first(1);
+         static_cast<void>(s1);
+     }
+     */
 
     // initialization or assignment to static span that requires size INCREASE is not ok.
     int arr2[2] = {1, 2};
 
-    static_assert(!ConversionCompilesFor<span<int, 4>, int[2]>,
-                  "!ConversionCompilesFor<span<int, 4>, int[2]>");
-    static_assert(!ConversionCompilesFor<span<int, 2>, int[2]>,
-                  "!ConversionCompilesFor<span<int, 2>, int[2]>");
-    static_assert(!ConversionCompilesFor<span<int, 4>, span<int, 2>>,
-                  "!ConversionCompilesFor<span<int, 4>, span<int, 2>>");
-
+#ifdef CONFIRM_COMPILATION_ERRORS
+    {
+        span<int, 4> s3 = arr2;
+    }
+    {
+        span<int, 2> s2 = arr2;
+        span<int, 4> s4a = s2;
+    }
+#endif
     {
         auto f = [&]() {
             const span<int, 4> _s4{arr2, 2};
@@ -1172,11 +1217,16 @@ TEST(span_test, fixed_size_conversions)
         EXPECT_DEATH(f(), expected);
     }
 
-    // This no longer compiles. There is no suitable conversion from dynamic span to a fixed size
-    // span.
-    // this should fail - we are trying to assign a small dynamic span to a fixed_size larger one
-    static_assert(!ConversionCompilesFor<span<int, 4>, span<int>>,
-                  "!ConversionCompilesFor<span<int, 4>, span<int>>");
+    /*
+     // This no longer compiles. There is no suitable conversion from dynamic span to a fixed size
+     span.
+     // this should fail - we are trying to assign a small dynamic span to a fixed_size larger one
+     span<int> av = arr2; auto f = [&]() {
+         const span<int, 4> _s4 = av;
+         static_cast<void>(_s4);
+     };
+     EXPECT_DEATH(f(), expected);
+     */
 }
 
 TEST(span_test, interop_with_std_regex)
@@ -1211,7 +1261,7 @@ TEST(span_test, default_constructible)
 
 TEST(span_test, std_container_ctad)
 {
-#if defined(__cpp_deduction_guides) && (__cpp_deduction_guides >= 201703L)
+#if (defined(__cpp_deduction_guides) && (__cpp_deduction_guides >= 201611L))
     // this test is just to verify that these compile
     {
         std::vector<int> v{1, 2, 3, 4};
@@ -1230,7 +1280,7 @@ TEST(span_test, std_container_ctad)
         static_assert(std::is_same<decltype(sp), gsl::span<const char>>::value);
     }
 #endif
-#endif // defined(__cpp_deduction_guides) && (__cpp_deduction_guides >= 201703L)
+#endif
 }
 
 TEST(span_test, front_back)
@@ -1267,162 +1317,3 @@ TEST(span_test, std_span)
     EXPECT_TRUE(std_span.size() == gsl_span.size());
 }
 #endif // defined(FORCE_STD_SPAN_TESTS) || defined(__cpp_lib_span) && __cpp_lib_span >= 202002L
-
-#if defined(__cpp_lib_span) && defined(__cpp_lib_ranges)
-// This test covers the changes in PR #1100
-TEST(span_test, msvc_compile_error_PR1100)
-{
-    int arr[]{1, 7, 2, 9};
-    gsl::span sp{arr, std::size(arr)};
-    std::ranges::sort(sp);
-    for (const auto& e : sp) { (void) e; }
-}
-#endif // defined(__cpp_lib_span) && defined(__cpp_lib_ranges)
-
-TEST(span_test, empty_span)
-{
-    span<int> s{};
-    EXPECT_TRUE(s.empty());
-    EXPECT_TRUE(s.size() == 0);
-    EXPECT_TRUE(s.data() == nullptr);
-
-    span<const int> cs{};
-    EXPECT_TRUE(cs.empty());
-    EXPECT_TRUE(cs.size() == 0);
-    EXPECT_TRUE(cs.data() == nullptr);
-}
-
-TEST(span_test, conversions)
-{
-    int arr[5] = {1, 2, 3, 4, 5};
-
-#if defined(__cpp_deduction_guides) && (__cpp_deduction_guides >= 201703L)
-    span s = arr;
-    span cs = s;
-#else  // ^^^ deduction guides /// no deduction guides vvv
-    span<int, 5> s = arr;
-    span<int, 5> cs = s;
-#endif // defined(__cpp_deduction_guides) && (__cpp_deduction_guides >= 201703L)
-
-    EXPECT_TRUE(cs.size() == s.size());
-    EXPECT_TRUE(cs.data() == s.data());
-
-    span<int, 5> fs = s;
-    EXPECT_TRUE(fs.size() == s.size());
-    EXPECT_TRUE(fs.data() == s.data());
-
-    span<const int, 5> cfs = s;
-    EXPECT_TRUE(cfs.size() == s.size());
-    EXPECT_TRUE(cfs.data() == s.data());
-}
-
-TEST(span_test, comparison_operators)
-{
-    int arr1[3] = {1, 2, 3};
-    int arr2[3] = {1, 2, 3};
-    int arr3[3] = {4, 5, 6};
-
-    span<int> s1 = arr1;
-    span<int> s2 = arr2;
-    span<int> s3 = arr3;
-
-    EXPECT_TRUE(s1 == s2);
-    EXPECT_FALSE(s1 != s2);
-    EXPECT_FALSE(s1 == s3);
-    EXPECT_TRUE(s1 != s3);
-    EXPECT_TRUE(s1 < s3);
-    EXPECT_FALSE(s3 < s1);
-    EXPECT_TRUE(s1 <= s2);
-    EXPECT_TRUE(s1 <= s3);
-    EXPECT_FALSE(s3 <= s1);
-    EXPECT_TRUE(s3 > s1);
-    EXPECT_FALSE(s1 > s3);
-    EXPECT_TRUE(s3 >= s1);
-    EXPECT_TRUE(s1 >= s2);
-    EXPECT_FALSE(s1 >= s3);
-}
-
-// ...existing code...
-
-#if defined(__cpp_lib_span) && __cpp_lib_span >= 202002L
-
-#include <span> // for std::span
-
-TEST(span_test, compare_empty_span)
-{
-    gsl::span<int> gsl_s{};
-    std::span<int> std_s{};
-
-    EXPECT_TRUE(gsl_s.empty());
-    EXPECT_TRUE(std_s.empty());
-    EXPECT_EQ(gsl_s.size(), std_s.size());
-    EXPECT_EQ(gsl_s.data(), std_s.data());
-}
-
-TEST(span_test, compare_subspan)
-{
-    int arr[5] = {1, 2, 3, 4, 5};
-    gsl::span gsl_s = arr;
-    std::span std_s = arr;
-
-    auto gsl_sub1 = gsl_s.subspan(1);
-    auto std_sub1 = std_s.subspan(1);
-    EXPECT_EQ(gsl_sub1.size(), std_sub1.size());
-    EXPECT_EQ(gsl_sub1.data(), std_sub1.data());
-
-    auto gsl_sub2 = gsl_s.subspan(1, 2);
-    auto std_sub2 = std_s.subspan(1, 2);
-    EXPECT_EQ(gsl_sub2.size(), std_sub2.size());
-    EXPECT_EQ(gsl_sub2.data(), std_sub2.data());
-}
-
-TEST(span_test, compare_conversions)
-{
-    int arr[5] = {1, 2, 3, 4, 5};
-    gsl::span gsl_s = arr;
-    std::span std_s = arr;
-
-    gsl::span gsl_cs = gsl_s;
-    std::span std_cs = std_s;
-    EXPECT_EQ(gsl_cs.size(), std_cs.size());
-    EXPECT_EQ(gsl_cs.data(), std_cs.data());
-
-    gsl::span<int, 5> gsl_fs = gsl_s;
-    std::span<int, 5> std_fs = std_s;
-    EXPECT_EQ(gsl_fs.size(), std_fs.size());
-    EXPECT_EQ(gsl_fs.data(), std_fs.data());
-
-    gsl::span<const int, 5> gsl_cfs = gsl_s;
-    std::span<const int, 5> std_cfs = std_s;
-    EXPECT_EQ(gsl_cfs.size(), std_cfs.size());
-    EXPECT_EQ(gsl_cfs.data(), std_cfs.data());
-}
-
-TEST(span_test, deduction_guides)
-{
-    int arr[5] = {1, 2, 3, 4, 5};
-    std::array<int, 5> std_arr = {1, 2, 3, 4, 5};
-    std::vector<int> vec = {1, 2, 3, 4, 5};
-
-    // Test deduction guides for gsl::span
-    gsl::span gsl_s1 = arr;
-    gsl::span gsl_s2 = std_arr;
-    gsl::span gsl_s3 = vec;
-
-    // Test deduction guides for std::span (for sanity checks)
-    std::span std_s1 = arr;
-    std::span std_s2 = std_arr;
-    std::span std_s3 = vec;
-
-    // Compare sizes
-    EXPECT_EQ(gsl_s1.size(), std_s1.size());
-    EXPECT_EQ(gsl_s2.size(), std_s2.size());
-    EXPECT_EQ(gsl_s3.size(), std_s3.size());
-
-    // Compare data pointers
-    EXPECT_EQ(gsl_s1.data(), std_s1.data());
-    EXPECT_EQ(gsl_s2.data(), std_s2.data());
-    EXPECT_EQ(gsl_s3.data(), std_s3.data());
-}
-
-#endif // defined(__cpp_lib_span) && __cpp_lib_span >= 202002L

tests/strict_notnull_tests.cpp

@@ -17,187 +17,37 @@
 #include <gsl/pointers> // for not_null, operator<, operator<=, operator>
 #include <gtest/gtest.h>
 
-#include <type_traits> // for declval
-
 #include "deathTestCommon.h"
 
 using namespace gsl;
 
-#if __cplusplus >= 201703l
-using std::void_t;
-#else  // __cplusplus >= 201703l
-template <class...>
-using void_t = void;
-#endif // __cplusplus < 201703l
-
-// stand-in for a user-defined ref-counted class
-template <typename T>
-struct RefCounted
-{
-    RefCounted(T* p) : p_(p) {}
-    operator T*() { return p_; }
-    T* p_;
-};
-
 namespace
 {
-GSL_SUPPRESS(f.4)
+// clang-format off
+GSL_SUPPRESS(f.4) // NO-FORMAT: attribute
+// clang-format on
 bool helper(not_null<int*> p) { return *p == 12; }
 
-GSL_SUPPRESS(f.4)
+// clang-format off
+GSL_SUPPRESS(f.4) // NO-FORMAT: attribute
+// clang-format on
 bool helper_const(not_null<const int*> p) { return *p == 12; }
 
-GSL_SUPPRESS(f.4)
+// clang-format off
+GSL_SUPPRESS(f.4) // NO-FORMAT: attribute
+// clang-format on
 bool strict_helper(strict_not_null<int*> p) { return *p == 12; }
 
-GSL_SUPPRESS(f.4)
+// clang-format off
+GSL_SUPPRESS(f.4) // NO-FORMAT: attribute
+// clang-format on
 bool strict_helper_const(strict_not_null<const int*> p) { return *p == 12; }
 
-int* return_pointer() { return nullptr; }
-} // namespace
-
-template <typename U, typename = void>
-static constexpr bool CtorCompilesFor_A = false;
-template <typename U>
-static constexpr bool
-    CtorCompilesFor_A<U, void_t<decltype(gsl::strict_not_null<void*>{std::declval<U>()})>> = true;
-
-template <typename U, int N, typename = void>
-static constexpr bool CtorCompilesFor_B = false;
-template <typename U, int N>
-static constexpr bool CtorCompilesFor_B<U, N, void_t<decltype(gsl::strict_not_null<U>{N})>> = true;
-
-template <typename U, typename = void>
-static constexpr bool DefaultCtorCompilesFor = false;
-template <typename U>
-static constexpr bool DefaultCtorCompilesFor<U, void_t<decltype(gsl::strict_not_null<U>{})>> = true;
-
-template <typename U, typename = void>
-static constexpr bool CtorCompilesFor_C = false;
-template <typename U>
-static constexpr bool CtorCompilesFor_C<
-    U, void_t<decltype(gsl::strict_not_null<U*>{std::declval<std::unique_ptr<U>>()})>> = true;
-
-TEST(strict_notnull_tests, TestStrictNotNullConstructors)
-{
-    {
-        static_assert(CtorCompilesFor_A<void*>, "CtorCompilesFor_A<void*>");
-        static_assert(!CtorCompilesFor_A<std::nullptr_t>, "!CtorCompilesFor_A<std::nullptr_t>");
-        static_assert(!CtorCompilesFor_B<void*, 0>, "!CtorCompilesFor_B<void*, 0>");
-        static_assert(!DefaultCtorCompilesFor<void*>, "!DefaultCtorCompilesFor<void*>");
-        static_assert(!CtorCompilesFor_C<int>, "CtorCompilesFor_C<int>");
 #ifdef CONFIRM_COMPILATION_ERRORS
-        // Forbid non-nullptr assignable types
-        strict_not_null<std::vector<int>> f(std::vector<int>{1});
-        strict_not_null<int> z(10);
-        strict_not_null<std::vector<int>> y({1, 2});
+int* return_pointer() { return nullptr; }
+const int* return_pointer_const() { return nullptr; }
 #endif
-    }
-
-    const auto terminateHandler = std::set_terminate([] {
-        std::cerr << "Expected Death. TestNotNullConstructors";
-        std::abort();
-    });
-    const auto expected = GetExpectedDeathString(terminateHandler);
-
-    {
-        // from shared pointer
-        int i = 12;
-        auto rp = RefCounted<int>(&i);
-        strict_not_null<int*> p(rp);
-        EXPECT_TRUE(p.get() == &i);
-
-        strict_not_null<std::shared_ptr<int>> x(
-            std::make_shared<int>(10)); // shared_ptr<int> is nullptr assignable
-
-        int* pi = nullptr;
-        EXPECT_DEATH((strict_not_null<decltype(pi)>(pi)), expected);
-    }
-
-    {
-        // from unique pointer
-        strict_not_null<std::unique_ptr<int>> x(
-            std::make_unique<int>(10)); // unique_ptr<int> is nullptr assignable
-
-        EXPECT_DEATH((strict_not_null<std::unique_ptr<int>>(std::unique_ptr<int>{})), expected);
-    }
-
-    {
-        // from pointer to local
-        int t = 42;
-
-        strict_not_null<int*> x{&t};
-        helper(&t);
-        helper_const(&t);
-
-        EXPECT_TRUE(*x == 42);
-    }
-
-    {
-        // from raw pointer
-        // from strict_not_null pointer
-
-        int t = 42;
-        int* p = &t;
-
-        strict_not_null<int*> x{p};
-        helper(p);
-        helper_const(p);
-        helper(x);
-        helper_const(x);
-
-        EXPECT_TRUE(*x == 42);
-    }
-
-    {
-        // from raw const pointer
-        // from strict_not_null const pointer
-
-        int t = 42;
-        const int* cp = &t;
-
-        strict_not_null<const int*> x{cp};
-        helper_const(cp);
-        helper_const(x);
-
-        EXPECT_TRUE(*x == 42);
-    }
-
-    {
-        // from strict_not_null const pointer, using auto
-        int t = 42;
-        const int* cp = &t;
-
-        auto x = strict_not_null<const int*>{cp};
-
-        EXPECT_TRUE(*x == 42);
-    }
-
-    {
-        // from returned pointer
-
-        EXPECT_DEATH(helper(return_pointer()), expected);
-        EXPECT_DEATH(helper_const(return_pointer()), expected);
-    }
-}
-
-template <typename U, typename = void>
-static constexpr bool StrictHelperCompilesFor = false;
-template <typename U>
-static constexpr bool
-    StrictHelperCompilesFor<U, void_t<decltype(strict_helper(std::declval<U>()))>> = true;
-
-template <typename U, typename = void>
-static constexpr bool StrictHelperConstCompilesFor = false;
-template <typename U>
-static constexpr bool
-    StrictHelperConstCompilesFor<U, void_t<decltype(strict_helper_const(std::declval<U>()))>> =
-        true;
-
-template <typename U, typename = void>
-static constexpr bool HelperCompilesFor = false;
-template <typename U>
-static constexpr bool HelperCompilesFor<U, void_t<decltype(helper(std::declval<U>()))>> = true;
+} // namespace
 
 TEST(strict_notnull_tests, TestStrictNotNull)
 {
@@ -207,42 +57,20 @@ TEST(strict_notnull_tests, TestStrictNotNull)
 
 #ifdef CONFIRM_COMPILATION_ERRORS
         strict_not_null<int*> snn = &x;
+        strict_helper(&x);
+        strict_helper_const(&x);
+        strict_helper(return_pointer());
+        strict_helper_const(return_pointer_const());
 #endif
-        static_assert(!StrictHelperCompilesFor<int*>, "!StrictHelperCompilesFor<int*>");
-        static_assert(!StrictHelperConstCompilesFor<int*>, "!StrictHelperCompilesFor<int*>");
 
         const strict_not_null<int*> snn1{&x};
 
-        static_assert(StrictHelperCompilesFor<const strict_not_null<int*>>,
-                      "StrictHelperCompilesFor<const strict_not_null<int*>>");
         helper(snn1);
         helper_const(snn1);
 
         EXPECT_TRUE(*snn1 == 42);
     }
 
-    {
-        // raw ptr <-> strict_not_null
-        const int x = 42;
-
-#ifdef CONFIRM_COMPILATION_ERRORS
-        strict_not_null<int*> snn = &x;
-#endif
-        static_assert(!StrictHelperCompilesFor<const int*>, "!StrictHelperFor<const int*>");
-        static_assert(!StrictHelperConstCompilesFor<const int*>,
-                      "!StrictHelperCompilesFor<const int*>");
-
-        const strict_not_null<const int*> snn1{&x};
-
-        static_assert(!HelperCompilesFor<const strict_not_null<const int*>>,
-                      "!HelperCompilesFor<const strict_not_null<const int*>>");
-        static_assert(StrictHelperConstCompilesFor<const strict_not_null<const int*>>,
-                      "StrictHelperCompilesFor<const strict_not_null<const int*>>");
-        helper_const(snn1);
-
-        EXPECT_TRUE(*snn1 == 42);
-    }
-
     {
         // strict_not_null -> strict_not_null
         int x = 42;
@@ -257,21 +85,6 @@ TEST(strict_notnull_tests, TestStrictNotNull)
         EXPECT_TRUE(snn1 == snn2);
     }
 
-    {
-        // strict_not_null -> strict_not_null
-        const int x = 42;
-
-        strict_not_null<const int*> snn1{&x};
-        const strict_not_null<const int*> snn2{&x};
-
-        static_assert(!StrictHelperCompilesFor<strict_not_null<const int*>>,
-                      "!StrictHelperCompilesFor<strict_not_null<const int*>>");
-        strict_helper_const(snn1);
-        strict_helper_const(snn2);
-
-        EXPECT_TRUE(snn1 == snn2);
-    }
-
     {
         // strict_not_null -> not_null
         int x = 42;
@@ -288,23 +101,6 @@ TEST(strict_notnull_tests, TestStrictNotNull)
         EXPECT_TRUE(snn == nn2);
     }
 
-    {
-        // strict_not_null -> not_null
-        const int x = 42;
-
-        strict_not_null<const int*> snn{&x};
-
-        const not_null<const int*> nn1 = snn;
-        const not_null<const int*> nn2{snn};
-
-        static_assert(!HelperCompilesFor<strict_not_null<const int*>>,
-                      "!HelperCompilesFor<strict_not_null<const int*>>");
-        helper_const(snn);
-
-        EXPECT_TRUE(snn == nn1);
-        EXPECT_TRUE(snn == nn2);
-    }
-
     {
         // not_null -> strict_not_null
         int x = 42;
@@ -329,37 +125,11 @@ TEST(strict_notnull_tests, TestStrictNotNull)
         EXPECT_TRUE(hash_snn(snn1) == hash_snn(nn));
     }
 
+#ifdef CONFIRM_COMPILATION_ERRORS
     {
-        // not_null -> strict_not_null
-        const int x = 42;
-
-        not_null<const int*> nn{&x};
-
-        const strict_not_null<const int*> snn1{nn};
-        const strict_not_null<const int*> snn2{nn};
-
-        static_assert(!StrictHelperCompilesFor<not_null<const int*>>,
-                      "!StrictHelperCompilesFor<not_null<const int*>>");
-        strict_helper_const(nn);
-
-        EXPECT_TRUE(snn1 == nn);
-        EXPECT_TRUE(snn2 == nn);
-
-        std::hash<strict_not_null<const int*>> hash_snn;
-        std::hash<not_null<const int*>> hash_nn;
-
-        EXPECT_TRUE(hash_nn(snn1) == hash_nn(nn));
-        EXPECT_TRUE(hash_snn(snn1) == hash_nn(nn));
-        EXPECT_TRUE(hash_nn(snn1) == hash_nn(snn2));
-        EXPECT_TRUE(hash_snn(snn1) == hash_snn(nn));
+        strict_not_null<int*> p{nullptr};
     }
-}
-
-TEST(pointers_test, member_types)
-{
-    // make sure `element_type` is inherited from `gsl::not_null`
-    static_assert(std::is_same<gsl::strict_not_null<int*>::element_type, int*>::value,
-                  "check member type: element_type");
+#endif
 }
 
 #if defined(__cplusplus) && (__cplusplus >= 201703L)
@@ -382,17 +152,6 @@ TEST(strict_notnull_tests, TestStrictNotNullConstructorTypeDeduction)
         EXPECT_TRUE(*x == 42);
     }
 
-    {
-        const int i = 42;
-
-        strict_not_null x{&i};
-        static_assert(!HelperCompilesFor<strict_not_null<const int*>>,
-                      "!HelperCompilesFor<strict_not_null<const int*>>");
-        helper_const(strict_not_null{&i});
-
-        EXPECT_TRUE(*x == 42);
-    }
-
     {
         int i = 42;
         int* p = &i;
@@ -404,18 +163,6 @@ TEST(strict_notnull_tests, TestStrictNotNullConstructorTypeDeduction)
         EXPECT_TRUE(*x == 42);
     }
 
-    {
-        const int i = 42;
-        const int* p = &i;
-
-        strict_not_null x{p};
-        static_assert(!HelperCompilesFor<strict_not_null<const int*>>,
-                      "!HelperCompilesFor<strict_not_null<const int*>>");
-        helper_const(strict_not_null{p});
-
-        EXPECT_TRUE(*x == 42);
-    }
-
     {
         auto workaround_macro = []() {
             int* p1 = nullptr;

tests/utils_tests.cpp

@@ -16,14 +16,14 @@
 
 #include <gtest/gtest.h>
 
-#include <algorithm> // for move
+#include <algorithm>   // for move
 #include <complex>
 #include <cstddef>     // for std::ptrdiff_t
-#include <cstdint>     // for uint32_t, int32_t
 #include <functional>  // for reference_wrapper, _Bind_helper<>::type
 #include <gsl/narrow>  // for narrow, narrowing_error
 #include <gsl/util>    // finally, narrow_cast
 #include <limits>      // for numeric_limits
+#include <stdint.h>    // for uint32_t, int32_t
 #include <type_traits> // for is_same
 
 using namespace gsl;
@@ -96,7 +96,7 @@ TEST(utils_tests, finally_function_with_bind)
 {
     int i = 0;
     {
-        auto _ = finally([&i] { return f(i); });
+        auto _ = finally(std::bind(&f, std::ref(i)));
         EXPECT_TRUE(i == 0);
     }
     EXPECT_TRUE(i == 1);
@@ -112,16 +112,6 @@ TEST(utils_tests, finally_function_ptr)
     EXPECT_TRUE(j == 1);
 }
 
-TEST(utils_tests, finally_function)
-{
-    j = 0;
-    {
-        auto _ = finally(g);
-        EXPECT_TRUE(j == 0);
-    }
-    EXPECT_TRUE(j == 1);
-}
-
 TEST(utils_tests, narrow_cast)
 {
     int n = 120;
@@ -156,8 +146,8 @@ TEST(utils_tests, narrow)
     n = -42;
     EXPECT_THROW(narrow<unsigned>(n), narrowing_error);
 
-    EXPECT_TRUE(narrow<std::complex<float>>(std::complex<double>(4, 2)) ==
-                std::complex<float>(4, 2));
+    EXPECT_TRUE(
+        narrow<std::complex<float>>(std::complex<double>(4, 2)) == std::complex<float>(4, 2));
     EXPECT_THROW(narrow<std::complex<float>>(std::complex<double>(4.2)), narrowing_error);
 
     EXPECT_TRUE(narrow<int>(float(1)) == 1);