Document BOOST_CORE_ALIGNOF

Mark boost::swap noexcept if the type supports non-throwing swap
implementation.

.drone.jsonnet

@@ -0,0 +1,370 @@
+# Copyright 2022 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+# https://www.boost.org/LICENSE_1_0.txt
+
+local library = "core";
+
+local triggers =
+{
+    branch: [ "master", "develop", "feature/*" ]
+};
+
+local ubsan = { UBSAN: '1', UBSAN_OPTIONS: 'print_stacktrace=1' };
+local asan = { ASAN: '1' };
+
+local linux_pipeline(name, image, environment, packages = "", sources = [], arch = "amd64") =
+{
+    name: name,
+    kind: "pipeline",
+    type: "docker",
+    trigger: triggers,
+    platform:
+    {
+        os: "linux",
+        arch: arch
+    },
+    steps:
+    [
+        {
+            name: "everything",
+            image: image,
+            environment: environment,
+            commands:
+            [
+                'set -e',
+                'wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | apt-key add -',
+            ] +
+            (if sources != [] then [ ('apt-add-repository "' + source + '"') for source in sources ] else []) +
+            (if packages != "" then [ 'apt-get update', 'apt-get -y install ' + packages ] else []) +
+            [
+                'export LIBRARY=' + library,
+                './.drone/drone.sh',
+            ]
+        }
+    ]
+};
+
+local macos_pipeline(name, environment, xcode_version = "12.2", osx_version = "catalina", arch = "amd64") =
+{
+    name: name,
+    kind: "pipeline",
+    type: "exec",
+    trigger: triggers,
+    platform: {
+        "os": "darwin",
+        "arch": arch
+    },
+    node: {
+        "os": osx_version
+    },
+    steps: [
+        {
+            name: "everything",
+            environment: environment + { "DEVELOPER_DIR": "/Applications/Xcode-" + xcode_version + ".app/Contents/Developer" },
+            commands:
+            [
+                'export LIBRARY=' + library,
+                './.drone/drone.sh',
+            ]
+        }
+    ]
+};
+
+local windows_pipeline(name, image, environment, arch = "amd64") =
+{
+    name: name,
+    kind: "pipeline",
+    type: "docker",
+    trigger: triggers,
+    platform:
+    {
+        os: "windows",
+        arch: arch
+    },
+    "steps":
+    [
+        {
+            name: "everything",
+            image: image,
+            environment: environment,
+            commands:
+            [
+                'cmd /C .drone\\\\drone.bat ' + library,
+            ]
+        }
+    ]
+};
+
+[
+    linux_pipeline(
+        "Linux 14.04 GCC 4.4",
+        "cppalliance/droneubuntu1404:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-4.4', CXXSTD: '98,0x' },
+        "g++-4.4",
+        [ "ppa:ubuntu-toolchain-r/test" ],
+    ),
+
+    linux_pipeline(
+        "Linux 14.04 GCC 4.6 32/64",
+        "cppalliance/droneubuntu1404:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-4.6', CXXSTD: '98,0x', ADDRMD: '32,64' },
+        "g++-4.6-multilib",
+        [ "ppa:ubuntu-toolchain-r/test" ],
+    ),
+
+    linux_pipeline(
+        "Linux 14.04 GCC 4.7 32/64",
+        "cppalliance/droneubuntu1404:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-4.7', CXXSTD: '98,0x', ADDRMD: '32,64' },
+        "g++-4.7-multilib",
+        [ "ppa:ubuntu-toolchain-r/test" ],
+    ),
+
+    linux_pipeline(
+        "Linux 14.04 GCC 4.8* 32/64",
+        "cppalliance/droneubuntu1404:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11', ADDRMD: '32,64' },
+    ),
+
+    linux_pipeline(
+        "Linux 14.04 GCC 4.9 32/64",
+        "cppalliance/droneubuntu1404:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-4.9', CXXSTD: '03,11', ADDRMD: '32,64' },
+        "g++-4.9-multilib",
+        [ "ppa:ubuntu-toolchain-r/test" ],
+    ),
+
+    linux_pipeline(
+        "Linux 16.04 GCC 5* 32/64",
+        "cppalliance/droneubuntu1604:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14', ADDRMD: '32,64' },
+    ),
+
+    linux_pipeline(
+        "Linux 18.04 GCC 6 32/64",
+        "cppalliance/droneubuntu1804:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-6', CXXSTD: '03,11,14', ADDRMD: '32,64' },
+        "g++-6-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 18.04 GCC 7* 32/64",
+        "cppalliance/droneubuntu1804:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14,17', ADDRMD: '32,64' },
+    ),
+
+    linux_pipeline(
+        "Linux 18.04 GCC 8 32/64",
+        "cppalliance/droneubuntu1804:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-8', CXXSTD: '03,11,14,17', ADDRMD: '32,64' },
+        "g++-8-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 GCC 9* 32/64",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14,17,2a', ADDRMD: '32,64' },
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 GCC 9* ARM64",
+        "cppalliance/droneubuntu2004:multiarch",
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14,17,2a' },
+        arch="arm64",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 GCC 9* S390x",
+        "cppalliance/droneubuntu2004:multiarch",
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14,17,2a' },
+        arch="s390x",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 GCC 10 32/64",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-10', CXXSTD: '03,11,14,17,20', ADDRMD: '32,64' },
+        "g++-10-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 22.04 GCC 11* 32/64",
+        "cppalliance/droneubuntu2204:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14,17,2a', ADDRMD: '32,64' },
+    ),
+
+    linux_pipeline(
+        "Linux 22.04 GCC 12 32 ASAN",
+        "cppalliance/droneubuntu2204:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-12', CXXSTD: '03,11,14,17,20,2b', ADDRMD: '32' } + asan,
+        "g++-12-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 22.04 GCC 12 64 ASAN",
+        "cppalliance/droneubuntu2204:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-12', CXXSTD: '03,11,14,17,20,2b', ADDRMD: '64' } + asan,
+        "g++-12-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 16.04 Clang 3.5",
+        "cppalliance/droneubuntu1604:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-3.5', CXXSTD: '03,11' },
+        "clang-3.5",
+    ),
+
+    linux_pipeline(
+        "Linux 16.04 Clang 3.6",
+        "cppalliance/droneubuntu1604:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-3.6', CXXSTD: '03,11,14' },
+        "clang-3.6",
+    ),
+
+    linux_pipeline(
+        "Linux 16.04 Clang 3.7",
+        "cppalliance/droneubuntu1604:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-3.7', CXXSTD: '03,11,14' },
+        "clang-3.7",
+    ),
+
+    linux_pipeline(
+        "Linux 16.04 Clang 3.8",
+        "cppalliance/droneubuntu1604:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-3.8', CXXSTD: '03,11,14' },
+        "clang-3.8",
+    ),
+
+    linux_pipeline(
+        "Linux 18.04 Clang 3.9",
+        "cppalliance/droneubuntu1804:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-3.9', CXXSTD: '03,11,14' },
+        "clang-3.9",
+    ),
+
+    linux_pipeline(
+        "Linux 18.04 Clang 4.0",
+        "cppalliance/droneubuntu1804:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-4.0', CXXSTD: '03,11,14' },
+        "clang-4.0",
+    ),
+
+    linux_pipeline(
+        "Linux 18.04 Clang 5.0",
+        "cppalliance/droneubuntu1804:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-5.0', CXXSTD: '03,11,14,1z' },
+        "clang-5.0",
+    ),
+
+    linux_pipeline(
+        "Linux 18.04 Clang 6.0",
+        "cppalliance/droneubuntu1804:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-6.0', CXXSTD: '03,11,14,17' },
+        "clang-6.0",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 Clang 7",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-7', CXXSTD: '03,11,14,17' },
+        "clang-7",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 Clang 8",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-8', CXXSTD: '03,11,14,17' },
+        "clang-8",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 Clang 9",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-9', CXXSTD: '03,11,14,17,2a' },
+        "clang-9",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 Clang 10",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-10', CXXSTD: '03,11,14,17,2a' },
+        "clang-10",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 Clang 11",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-11', CXXSTD: '03,11,14,17,2a' },
+        "clang-11",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 Clang 12",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-12', CXXSTD: '03,11,14,17,2a' },
+        "clang-12",
+    ),
+
+    linux_pipeline(
+        "Linux 22.04 Clang 13",
+        "cppalliance/droneubuntu2204:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-13', CXXSTD: '03,11,14,17,20' },
+        "clang-13",
+    ),
+
+    linux_pipeline(
+        "Linux 22.04 Clang 14 UBSAN",
+        "cppalliance/droneubuntu2204:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-14', CXXSTD: '03,11,14,17,20,2b' } + ubsan,
+        "clang-14",
+    ),
+
+    linux_pipeline(
+        "Linux 22.04 Clang 14 ASAN",
+        "cppalliance/droneubuntu2204:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-14', CXXSTD: '03,11,14,17,20,2b' } + asan,
+        "clang-14",
+    ),
+
+    linux_pipeline(
+        "Linux 22.04 Clang 15",
+        "cppalliance/droneubuntu2204:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-15', CXXSTD: '03,11,14,17,20,2b' },
+        "clang-15",
+        ["deb http://apt.llvm.org/jammy/ llvm-toolchain-jammy-15 main"],
+    ),
+
+    macos_pipeline(
+        "MacOS 10.15 Xcode 12.2 UBSAN",
+        { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '03,11,14,1z' } + ubsan,
+    ),
+
+    macos_pipeline(
+        "MacOS 10.15 Xcode 12.2 ASAN",
+        { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '03,11,14,1z' } + asan,
+    ),
+
+    windows_pipeline(
+        "Windows VS2015 msvc-14.0",
+        "cppalliance/dronevs2015",
+        { TOOLSET: 'msvc-14.0', CXXSTD: '14,latest' },
+    ),
+
+    windows_pipeline(
+        "Windows VS2017 msvc-14.1",
+        "cppalliance/dronevs2017",
+        { TOOLSET: 'msvc-14.1', CXXSTD: '14,17,latest' },
+    ),
+
+    windows_pipeline(
+        "Windows VS2019 msvc-14.2",
+        "cppalliance/dronevs2019",
+        { TOOLSET: 'msvc-14.2', CXXSTD: '14,17,20,latest' },
+    ),
+
+    windows_pipeline(
+        "Windows VS2022 msvc-14.3",
+        "cppalliance/dronevs2022:1",
+        { TOOLSET: 'msvc-14.3', CXXSTD: '14,17,20,latest' },
+    ),
+]

.drone/drone.bat

@@ -0,0 +1,23 @@
+@REM Copyright 2022 Peter Dimov
+@REM Distributed under the Boost Software License, Version 1.0.
+@REM https://www.boost.org/LICENSE_1_0.txt
+
+@ECHO ON
+
+set LIBRARY=%1
+set DRONE_BUILD_DIR=%CD%
+
+set BOOST_BRANCH=develop
+if "%DRONE_BRANCH%" == "master" set BOOST_BRANCH=master
+cd ..
+git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
+cd boost-root
+git submodule update --init tools/boostdep
+xcopy /s /e /q %DRONE_BUILD_DIR% libs\%LIBRARY%\
+python tools/boostdep/depinst/depinst.py -I examples %LIBRARY%
+cmd /c bootstrap
+b2 -d0 headers
+
+if not "%CXXSTD%" == "" set CXXSTD=cxxstd=%CXXSTD%
+if not "%ADDRMD%" == "" set ADDRMD=address-model=%ADDRMD%
+b2 -j3 libs/%LIBRARY%/test toolset=%TOOLSET% %CXXSTD% %ADDRMD% variant=debug,release embed-manifest-via=linker

.drone/drone.sh

@@ -0,0 +1,24 @@
+#!/bin/bash
+
+# Copyright 2022 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+# https://www.boost.org/LICENSE_1_0.txt
+
+set -ex
+
+DRONE_BUILD_DIR=$(pwd)
+
+BOOST_BRANCH=develop
+if [ "$DRONE_BRANCH" = "master" ]; then BOOST_BRANCH=master; fi
+
+cd ..
+git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+cd boost-root
+git submodule update --init tools/boostdep
+cp -r $DRONE_BUILD_DIR/* libs/$LIBRARY
+python tools/boostdep/depinst/depinst.py -I examples $LIBRARY
+./bootstrap.sh
+./b2 -d0 headers
+
+echo "using $TOOLSET : : $COMPILER ;" > ~/user-config.jam
+./b2 -j3 libs/$LIBRARY/test toolset=$TOOLSET cxxstd=$CXXSTD variant=debug,release ${ADDRMD:+address-model=$ADDRMD} ${UBSAN:+undefined-sanitizer=norecover debug-symbols=on} ${ASAN:+address-sanitizer=norecover debug-symbols=on} ${LINKFLAGS:+linkflags=$LINKFLAGS}

.github/workflows/ci.yml

@@ -32,82 +32,95 @@ jobs:
           # Linux, gcc
           - toolset: gcc-4.4
             cxxstd: "98,0x"
+            address-model: 32,64
             os: ubuntu-latest
             container: ubuntu:16.04
             install:
-              - g++-4.4
+              - g++-4.4-multilib
             sources:
               - "ppa:ubuntu-toolchain-r/test"
           - toolset: gcc-4.6
             cxxstd: "03,0x"
+            address-model: 32,64
             os: ubuntu-latest
             container: ubuntu:16.04
             install:
-              - g++-4.6
+              - g++-4.6-multilib
             sources:
               - "ppa:ubuntu-toolchain-r/test"
           - toolset: gcc-4.7
             cxxstd: "03,11"
+            address-model: 32,64
             os: ubuntu-latest
             container: ubuntu:16.04
             install:
-              - g++-4.7
+              - g++-4.7-multilib
           - toolset: gcc-4.8
             cxxstd: "03,11"
+            address-model: 32,64
             os: ubuntu-latest
             container: ubuntu:18.04
             install:
-              - g++-4.8
+              - g++-4.8-multilib
           - toolset: gcc-4.9
             cxxstd: "03,11"
+            address-model: 32,64
             os: ubuntu-latest
             container: ubuntu:16.04
             install:
-              - g++-4.9
+              - g++-4.9-multilib
           - toolset: gcc-5
             cxxstd: "03,11,14,1z"
+            address-model: 32,64
             os: ubuntu-latest
             container: ubuntu:16.04
             install:
-              - g++-5
+              - g++-5-multilib
           - toolset: gcc-6
             cxxstd: "03,11,14,1z"
+            address-model: 32,64
             os: ubuntu-latest
             container: ubuntu:18.04
             install:
-              - g++-6
+              - g++-6-multilib
           - toolset: gcc-7
             cxxstd: "03,11,14,17"
+            address-model: 32,64
             os: ubuntu-latest
             container: ubuntu:18.04
             install:
-              - g++-7
+              - g++-7-multilib
           - toolset: gcc-8
             cxxstd: "03,11,14,17,2a"
+            address-model: 32,64
             os: ubuntu-latest
             container: ubuntu:18.04
             install:
-              - g++-8
+              - g++-8-multilib
           - toolset: gcc-9
             cxxstd: "03,11,14,17,2a"
+            address-model: 32,64
             os: ubuntu-20.04
             install:
-              - g++-9
+              - g++-9-multilib
           - toolset: gcc-10
             cxxstd: "03,11,14,17,20"
+            address-model: 32,64
             os: ubuntu-20.04
             install:
-              - g++-10
+              - g++-10-multilib
           - toolset: gcc-11
             cxxstd: "03,11,14,17,20,23"
+            address-model: 32,64
             os: ubuntu-22.04
             install:
-              - g++-11
+              - g++-11-multilib
           - toolset: gcc-12
             cxxstd: "03,11,14,17,20,23"
+            address-model: 32,64
             os: ubuntu-22.04
             install:
-              - g++-12
+              - g++-12-multilib
           - name: UBSAN
             toolset: gcc-12
             cxxstd: "03,11,14,17,20,23"
@@ -266,6 +279,9 @@ jobs:
           - toolset: clang
             cxxstd: "03,11,14,17,2a"
             os: macos-11
+          - toolset: clang
+            cxxstd: "03,11,14,17,2a"
+            os: macos-12
 
     timeout-minutes: 120
     runs-on: ${{matrix.os}}
@@ -456,6 +472,10 @@ jobs:
             then
                 B2_ARGS+=("cxxflags=${{matrix.cxxflags}}")
             fi
+            if [ -n "${{matrix.address-model}}" ]
+            then
+                B2_ARGS+=("address-model=${{matrix.address-model}}")
+            fi
             if [ -n "${{matrix.linkflags}}" ]
             then
                 B2_ARGS+=("linkflags=${{matrix.linkflags}}")
@@ -530,6 +550,7 @@ jobs:
           - os: ubuntu-20.04
           - os: ubuntu-22.04
           - os: macos-11
+          - os: macos-12
 
     runs-on: ${{matrix.os}}
 
@@ -576,6 +597,7 @@ jobs:
           - os: ubuntu-20.04
           - os: ubuntu-22.04
           - os: macos-11
+          - os: macos-12
 
     runs-on: ${{matrix.os}}
 
@@ -632,6 +654,7 @@ jobs:
           - os: ubuntu-20.04
           - os: ubuntu-22.04
           - os: macos-11
+          - os: macos-12
 
     runs-on: ${{matrix.os}}
 

CMakeLists.txt

@@ -20,6 +20,15 @@ target_link_libraries(boost_core
     Boost::throw_exception
 )
 
+if(CMAKE_VERSION VERSION_GREATER 3.18 AND CMAKE_GENERATOR MATCHES "Visual Studio")
+
+  file(GLOB_RECURSE boost_core_IDEFILES CONFIGURE_DEPENDS include/*.hpp)
+  source_group(TREE ${PROJECT_SOURCE_DIR}/include FILES ${boost_core_IDEFILES} PREFIX "Header Files")
+  list(APPEND boost_core_IDEFILES extra/boost_core.natvis)
+  target_sources(boost_core PRIVATE ${boost_core_IDEFILES})
+
+endif()
+
 if(BUILD_TESTING AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/test/CMakeLists.txt")
 
   add_subdirectory(test)

appveyor.yml

@@ -29,6 +29,11 @@ environment:
 
     # clang-win 32 bit fails to link with "unable to load mspdbcore.dll (error code: 126)"
 
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      TOOLSET: clang-win
+      ADDRMD: 64
+      CXXSTD: 14,17,latest
+
     - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
       TOOLSET: clang-win
       ADDRMD: 64
@@ -59,6 +64,13 @@ environment:
       TOOLSET: gcc
       CXXSTD: 03,11,14,1z
 
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      CMAKE: 1
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      CMAKE_SUBDIR: 1
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
+      CMAKE_INSTALL: 1
+
 install:
   - set GIT_FETCH_JOBS=8
   - set BOOST_BRANCH=develop
@@ -70,7 +82,7 @@ install:
   - xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\core\
   - python tools/boostdep/depinst/depinst.py --git_args "--jobs %GIT_FETCH_JOBS%" core
   - cmd /c bootstrap
-  - b2 headers
+  - b2 -d0 headers
 
 build: off
 
@@ -78,4 +90,27 @@ test_script:
   - PATH=%ADDPATH%%PATH%
   - if not "%CXXSTD%" == "" set CXXSTD=cxxstd=%CXXSTD%
   - if not "%ADDRMD%" == "" set ADDRMD=address-model=%ADDRMD%
-  - b2 -j %NUMBER_OF_PROCESSORS% libs/core/test toolset=%TOOLSET% %CXXSTD% %ADDRMD% variant=debug,release embed-manifest-via=linker
+  - if "%CMAKE%%CMAKE_SUBDIR%%CMAKE_INSTALL%" == ""  b2 -j %NUMBER_OF_PROCESSORS% libs/core/test toolset=%TOOLSET% %CXXSTD% %ADDRMD% variant=debug,release embed-manifest-via=linker
+
+  - if not "%CMAKE%" == ""  mkdir __build__ && cd __build__
+  - if not "%CMAKE%" == ""  cmake -DBUILD_TESTING=ON -DBOOST_INCLUDE_LIBRARIES=core ..
+  - if not "%CMAKE%" == ""  cmake --build . --target tests -j 3 --config Debug & ctest --output-on-failure --no-tests=error -j 3 -C Debug
+  - if not "%CMAKE%" == ""  cmake --build . --target tests -j 3 --config Release & ctest --output-on-failure --no-tests=error -j 3 -C Release
+  - if not "%CMAKE%" == ""  cmake --build . --target tests -j 3 --config MinSizeRel & ctest --output-on-failure --no-tests=error -j 3 -C MinSizeRel
+  - if not "%CMAKE%" == ""  cmake --build . --target tests -j 3 --config RelWithDebInfo & ctest --output-on-failure --no-tests=error -j 3 -C RelWithDebInfo
+
+  - if not "%CMAKE_SUBDIR%" == ""  cd libs/core/test/cmake_subdir_test && mkdir __build__ && cd __build__
+  - if not "%CMAKE_SUBDIR%" == ""  cmake ..
+  - if not "%CMAKE_SUBDIR%" == ""  cmake --build . --config Debug && cmake --build . --target check --config Debug
+  - if not "%CMAKE_SUBDIR%" == ""  cmake --build . --config Release && cmake --build . --target check --config Release
+  - if not "%CMAKE_SUBDIR%" == ""  cmake --build . --config MinSizeRel && cmake --build . --target check --config MinSizeRel
+  - if not "%CMAKE_SUBDIR%" == ""  cmake --build . --config RelWithDebInfo && cmake --build . --target check --config RelWithDebInfo
+
+  - if not "%CMAKE_INSTALL%" == ""  mkdir __build__ && cd __build__
+  - if not "%CMAKE_INSTALL%" == ""  cmake -DBOOST_INCLUDE_LIBRARIES=core -DCMAKE_INSTALL_PREFIX=C:/cmake-prefix ..
+  - if not "%CMAKE_INSTALL%" == ""  cmake --build . --target install --config Debug
+  - if not "%CMAKE_INSTALL%" == ""  cmake --build . --target install --config Release
+  - if not "%CMAKE_INSTALL%" == ""  cd ../libs/core/test/cmake_install_test && mkdir __build__ && cd __build__
+  - if not "%CMAKE_INSTALL%" == ""  cmake -DCMAKE_INSTALL_PREFIX=C:/cmake-prefix ..
+  - if not "%CMAKE_INSTALL%" == ""  cmake --build . --config Debug && cmake --build . --target check --config Debug
+  - if not "%CMAKE_INSTALL%" == ""  cmake --build . --config Release && cmake --build . --target check --config Release

doc/alignof.qbk

@@ -0,0 +1,33 @@
+[/
+  Copyright 2023 Peter Dimov
+  Distributed under the Boost Software License, Version 1.0.
+  https://boost.org/LICENSE_1_0.txt
+]
+
+[section:alignof alignof]
+
+[simplesect Authors]
+
+* Peter Dimov
+
+[endsimplesect]
+
+[section Header <boost/core/alignof.hpp>]
+
+The header `<boost/core/alignof.hpp>` defines the macro `BOOST_CORE_ALIGNOF`,
+a portable equivalent of the `alignof` operator from C++11.
+
+[section Example]
+
+``
+#include <boost/core/alignof.hpp>
+#include <cstddef>
+
+constexpr std::size_t alignment_of_double = BOOST_CORE_ALIGNOF(double);
+``
+
+[endsect]
+
+[endsect]
+
+[endsect]

doc/changes.qbk

@@ -14,6 +14,10 @@
 * Deprecated `boost/core/is_same.hpp` and `boost::core::is_same`. The header will be removed in a future release.
   Users are advised to use [@http://www.boost.org/doc/libs/release/libs/type_traits/doc/html/index.html Boost.TypeTraits]
   or C++ standard library type traits instead.
+* Marked `boost::ref` member functions and associated methods with `noexcept`.
+* Marked `boost::swap` function with `noexcept`, depending on whether the type supports a non-throwing swap operation.
+* Added `boost::core::launder`, a portable implementation of `std::launder`.
+* Added `BOOST_CORE_ALIGNOF`, a portable implementation of `alignof`.
 
 [endsect]
 

doc/core.qbk

@@ -41,6 +41,7 @@ criteria for inclusion is that the utility component be:
 [include changes.qbk]
 
 [include addressof.qbk]
+[include alignof.qbk]
 [include allocator_access.qbk]
 [include allocator_traits.qbk]
 [include bit.qbk]
@@ -55,6 +56,7 @@ criteria for inclusion is that the utility component be:
 [include first_scalar.qbk]
 [include ignore_unused.qbk]
 [include is_same.qbk]
+[include launder.qbk]
 [include lightweight_test.qbk]
 [include no_exceptions_support.qbk]
 [include noinit_adaptor.qbk]

doc/launder.qbk

@@ -0,0 +1,39 @@
+[/
+  Copyright 2023 Peter Dimov
+  Distributed under the Boost Software License, Version 1.0.
+  https://boost.org/LICENSE_1_0.txt
+]
+
+[section:launder launder]
+
+[simplesect Authors]
+
+* Peter Dimov
+
+[endsimplesect]
+
+[section Header <boost/core/launder.hpp>]
+
+The header `<boost/core/launder.hpp>` defines the function
+`void boost::core::launder()`, a portable implementation of
+`std::launder`.
+
+[section Synopsis]
+
+``
+namespace boost
+{
+namespace core
+{
+
+template<class T> T* launder( T* p );
+
+} // namespace core
+} // namespace boost
+``
+
+[endsect]
+
+[endsect]
+
+[endsect]

doc/swap.qbk

@@ -22,7 +22,7 @@
 
 [section Header <boost/core/swap.hpp>]
 
-`template<class T> void swap(T& left, T& right);`
+[^template<class T> void swap(T& left, T& right) noexcept(['see below]);]
 
 [endsect]
 
@@ -40,13 +40,14 @@ specialized swap function is available, `std::swap` is used.
 The generic `std::swap` function requires that the elements
 to be swapped are assignable and copy constructible. It is
 usually implemented using one copy construction and two
-assignments - this is often both unnecessarily restrictive and
-unnecessarily slow. In addition, where the generic swap
-implementation provides only the basic guarantee, specialized
-swap functions are often able to provide the no-throw exception
-guarantee (and it is considered best practice to do so where
-possible [footnote Scott Meyers, Effective C++ Third Edition,
-Item 25: "Consider support for a non-throwing swap"].
+assignments (C++11 replaces copy operations with move) - this
+is often both unnecessarily restrictive and unnecessarily slow.
+In addition, where the generic swap implementation provides
+only the basic guarantee, specialized swap functions are often
+able to provide the no-throw exception guarantee (and it is
+considered best practice to do so where possible[footnote Scott
+Meyers, Effective C++ Third Edition, Item 25: "Consider support
+for a non-throwing swap"].
 
 The alternative to using argument dependent lookup in this
 situation is to provide a template specialization of
@@ -59,12 +60,12 @@ in their own namespaces.
 `std::swap` originally did not do so, but a request to add an
 overload of `std::swap` for built-in arrays has been accepted
 by the C++ Standards Committee[footnote
-  [@http://open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#809 
+  [@http://open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#809
   LWG Defect Report 809: std::swap should be overloaded for array
   types]].
 
 [endsect]
-    
+
 [section Exception Safety]
 
 `boost::swap` provides the same exception guarantee as the
@@ -73,30 +74,33 @@ of type `T[n]`, where `n > 1` and the underlying swap function
 for `T` provides the strong exception guarantee, `boost::swap`
 provides only the basic exception guarantee.
 
+In C++11 and later, `boost::swap` propagates the same `noexcept`
+specification as the one specified in the underlying swap function.
+
 [endsect]
 
 [section Requirements]
 
 Either:
 
-* T must be assignable
-* T must be copy constructible
+* `T` must be copy assignable (/since C++11:/ move assignable)
+* `T` must be copy constructible (/since C++11:/ move constructible)
 
 Or:
 
-* A function with the signature `swap(T&,T&)` is available via
+* A function with the signature `swap(T&, T&)` is available via
   argument dependent lookup
 
 Or:
 
-* A template specialization of `std::swap` exists for T
+* A template specialization of `std::swap` exists for `T`
 
 Or:
 
-* T is a built-in array of swappable elements
+* `T` is a built-in array of swappable elements
 
 [endsect]
-    
+
 [section Portability]
 
 Several older compilers do not support argument dependent
@@ -104,11 +108,11 @@ lookup. On these compilers `boost::swap` will call
 `std::swap`, ignoring any specialized swap functions that
 could be found as a result of argument dependent lookup.
 
-[endsect]    
+[endsect]
 
 [section Credits]
 
-* *Niels Dekker* - for implementing and documenting support for 
+* *Niels Dekker* - for implementing and documenting support for
   built-in arrays
 * *Joseph Gauterin* - for the initial idea, implementation,
   tests, and documentation

extra/boost_core.natvis

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<AutoVisualizer xmlns="http://schemas.microsoft.com/vstudio/debugger/natvis/2010">
+
+  <Type Name="boost::core::basic_string_view&lt;*&gt;">
+    <DisplayString>{p_,[n_]s}</DisplayString>
+  </Type>
+
+</AutoVisualizer>

include/boost/core/alignof.hpp

@@ -0,0 +1,57 @@
+#ifndef BOOST_CORE_MAX_ALIGN_HPP_INCLUDED
+#define BOOST_CORE_MAX_ALIGN_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//  Copyright 2023 Peter Dimov
+//  Distributed under the Boost Software License, Version 1.0.
+//  https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/config.hpp>
+#include <cstddef>
+
+#if !defined(BOOST_NO_CXX11_ALIGNOF)
+
+#define BOOST_CORE_ALIGNOF alignof
+
+#elif defined(__GNUC__)
+
+#define BOOST_CORE_ALIGNOF __alignof__
+
+#elif defined(_MSC_VER)
+
+#define BOOST_CORE_ALIGNOF __alignof
+
+#else
+
+namespace boost
+{
+namespace core
+{
+namespace detail
+{
+
+template<class T> struct alignof_helper
+{
+    char x;
+    T t;
+};
+
+} // namespace detail
+} // namespace core
+} // namespace boost
+
+#if defined(__GNUC__)
+// ignoring -Wvariadic-macros with #pragma doesn't work under GCC
+# pragma GCC system_header
+#endif
+
+#define BOOST_CORE_ALIGNOF(...) offsetof( ::boost::core::detail::alignof_helper<__VA_ARGS__>, t );
+
+#endif
+
+#endif  // #ifndef BOOST_CORE_MAX_ALIGN_HPP_INCLUDED

include/boost/core/detail/lwt_unattended.hpp

@@ -27,6 +27,23 @@ inline void lwt_unattended()
     // disable message boxes on assert(), abort()
     ::_set_abort_behavior( 0, _WRITE_ABORT_MSG | _CALL_REPORTFAULT );
 
+# pragma warning(push)
+# pragma warning(disable: 4996)
+
+# if defined(__clang__)
+#  pragma clang diagnostic push
+#  pragma clang diagnostic ignored "-Wdeprecated-declarations"
+# endif
+
+    // disable message box on crash
+    ::_seterrormode( /*SEM_NOGPFAULTERRORBOX*/ 0x0002 );
+
+# if defined(__clang__)
+#  pragma clang diagnostic pop
+# endif
+
+# pragma warning(pop)
+
 #endif
 
 #if defined(_MSC_VER) && defined(_CPPLIB_VER) && defined(_DEBUG)

include/boost/core/launder.hpp

@@ -0,0 +1,55 @@
+#ifndef BOOST_CORE_LAUNDER_HPP_INCLUDED
+#define BOOST_CORE_LAUNDER_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//  Copyright 2023 Peter Dimov
+//  Distributed under the Boost Software License, Version 1.0.
+//  https://www.boost.org/LICENSE_1_0.txt
+
+#if defined(__has_builtin)
+# if __has_builtin(__builtin_launder)
+#  define BOOST_CORE_HAS_BUILTIN_LAUNDER
+# endif
+#endif
+
+#if (__cplusplus >= 201703L || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)) && !defined(BOOST_CORE_HAS_BUILTIN_LAUNDER)
+# include <new>
+#endif
+
+namespace boost
+{
+namespace core
+{
+
+#if defined(BOOST_CORE_HAS_BUILTIN_LAUNDER)
+
+template<class T> T* launder( T* p )
+{
+    return __builtin_launder( p );
+}
+
+#elif (__cplusplus >= 201703L || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)) && defined(__cpp_lib_launder)
+
+template<class T> T* launder( T* p )
+{
+    return std::launder( p );
+}
+
+#else
+
+template<class T> T* launder( T* p )
+{
+    return p;
+}
+
+#endif
+
+} // namespace core
+} // namespace boost
+
+#endif  // #ifndef BOOST_CORE_LAUNDER_HPP_INCLUDED

include/boost/core/ref.hpp

@@ -1,17 +1,15 @@
 #ifndef BOOST_CORE_REF_HPP
 #define BOOST_CORE_REF_HPP
 
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
 #include <boost/config.hpp>
 #include <boost/config/workaround.hpp>
 #include <boost/core/addressof.hpp>
 #include <boost/core/enable_if.hpp>
 
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+# pragma once
+#endif
+
 //
 //  ref.hpp - ref/cref, useful helper functions
 //
@@ -61,9 +59,11 @@ template< class Y, class T > struct ref_convertible
     enum _vt { value = sizeof( (f)( static_cast<Y*>(0) ) ) == sizeof(yes) };
 };
 
+#if defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS)
 struct ref_empty
 {
 };
+#endif
 
 } // namespace detail
 
@@ -92,11 +92,11 @@ public:
 
      @remark Does not throw.
     */
-    BOOST_FORCEINLINE explicit reference_wrapper(T& t): t_(boost::addressof(t)) {}
+    BOOST_FORCEINLINE explicit reference_wrapper(T& t) BOOST_NOEXCEPT : t_(boost::addressof(t)) {}
 
 #if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, == 1600 )
 
-    BOOST_FORCEINLINE explicit reference_wrapper( T & t, ref_workaround_tag ): t_( boost::addressof( t ) ) {}
+    BOOST_FORCEINLINE explicit reference_wrapper( T & t, ref_workaround_tag ) BOOST_NOEXCEPT : t_( boost::addressof( t ) ) {}
 
 #endif
 
@@ -117,30 +117,37 @@ public:
      @remark Only enabled when `Y*` is convertible to `T*`.
      @remark Does not throw.
     */
-    template<class Y> reference_wrapper( reference_wrapper<Y> r,
-        typename enable_if_c<boost::detail::ref_convertible<Y, T>::value,
-            boost::detail::ref_empty>::type = boost::detail::ref_empty() ): t_( r.t_ )
+#if !defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS)
+    template<class Y, class = typename enable_if_c<boost::detail::ref_convertible<Y, T>::value>::type>
+    reference_wrapper( reference_wrapper<Y> r ) BOOST_NOEXCEPT : t_( r.t_ )
     {
     }
+#else
+    template<class Y> reference_wrapper( reference_wrapper<Y> r,
+        typename enable_if_c<boost::detail::ref_convertible<Y, T>::value,
+            boost::detail::ref_empty>::type = boost::detail::ref_empty() ) BOOST_NOEXCEPT : t_( r.t_ )
+    {
+    }
+#endif
 
     /**
      @return The stored reference.
      @remark Does not throw.
     */
-    BOOST_FORCEINLINE operator T& () const { return *t_; }
+    BOOST_FORCEINLINE operator T& () const BOOST_NOEXCEPT { return *t_; }
 
     /**
      @return The stored reference.
      @remark Does not throw.
     */
-    BOOST_FORCEINLINE T& get() const { return *t_; }
+    BOOST_FORCEINLINE T& get() const BOOST_NOEXCEPT { return *t_; }
 
     /**
      @return A pointer to the object referenced by the stored
        reference.
      @remark Does not throw.
     */
-    BOOST_FORCEINLINE T* get_pointer() const { return t_; }
+    BOOST_FORCEINLINE T* get_pointer() const BOOST_NOEXCEPT { return t_; }
 
 private:
 
@@ -165,7 +172,7 @@ private:
  @return `reference_wrapper<T>(t)`
  @remark Does not throw.
 */
-template<class T> BOOST_FORCEINLINE reference_wrapper<T> BOOST_REF_CONST ref( T & t )
+template<class T> BOOST_FORCEINLINE reference_wrapper<T> BOOST_REF_CONST ref( T & t ) BOOST_NOEXCEPT
 {
 #if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, == 1600 )
 
@@ -184,7 +191,7 @@ template<class T> BOOST_FORCEINLINE reference_wrapper<T> BOOST_REF_CONST ref( T
  @return `reference_wrapper<T const>(t)`
  @remark Does not throw.
 */
-template<class T> BOOST_FORCEINLINE reference_wrapper<T const> BOOST_REF_CONST cref( T const & t )
+template<class T> BOOST_FORCEINLINE reference_wrapper<T const> BOOST_REF_CONST cref( T const & t ) BOOST_NOEXCEPT
 {
     return reference_wrapper<T const>(t);
 }
@@ -315,7 +322,7 @@ template<typename T> struct unwrap_reference< reference_wrapper<T> const volatil
  @return `unwrap_reference<T>::type&(t)`
  @remark Does not throw.
 */
-template<class T> BOOST_FORCEINLINE typename unwrap_reference<T>::type& unwrap_ref( T & t )
+template<class T> BOOST_FORCEINLINE typename unwrap_reference<T>::type& unwrap_ref( T & t ) BOOST_NOEXCEPT
 {
     return t;
 }
@@ -325,7 +332,7 @@ template<class T> BOOST_FORCEINLINE typename unwrap_reference<T>::type& unwrap_r
 /**
  @cond
 */
-template<class T> BOOST_FORCEINLINE T* get_pointer( reference_wrapper<T> const & r )
+template<class T> BOOST_FORCEINLINE T* get_pointer( reference_wrapper<T> const & r ) BOOST_NOEXCEPT
 {
     return r.get_pointer();
 }

include/boost/core/swap.hpp

@@ -13,10 +13,10 @@
 // - swap_impl is put outside the boost namespace, to avoid infinite
 // recursion (causing stack overflow) when swapping objects of a primitive
 // type.
-// - swap_impl has a using-directive, rather than a using-declaration,
-// because some compilers (including MSVC 7.1, Borland 5.9.3, and
-// Intel 8.1) don't do argument-dependent lookup when it has a
-// using-declaration instead.
+// - std::swap is imported with a using-directive, rather than
+// a using-declaration, because some compilers (including MSVC 7.1,
+// Borland 5.9.3, and Intel 8.1) don't do argument-dependent lookup
+// when it has a using-declaration instead.
 // - boost::swap has two template arguments, instead of one, to
 // avoid ambiguity when swapping objects of a Boost type that does
 // not have its own boost::swap overload.
@@ -30,6 +30,17 @@
 #endif
 #include <cstddef> // for std::size_t
 
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+#if defined(BOOST_GCC) && (BOOST_GCC < 40700)
+// gcc 4.6 ICEs on noexcept specifications below
+#define BOOST_CORE_SWAP_NOEXCEPT_IF(x)
+#else
+#define BOOST_CORE_SWAP_NOEXCEPT_IF(x) BOOST_NOEXCEPT_IF(x)
+#endif
+
 namespace boost_swap_impl
 {
   // we can't use type_traits here
@@ -37,17 +48,22 @@ namespace boost_swap_impl
   template<class T> struct is_const { enum _vt { value = 0 }; };
   template<class T> struct is_const<T const> { enum _vt { value = 1 }; };
 
+  // Use std::swap if argument dependent lookup fails.
+  // We need to have this at namespace scope to be able to use unqualified swap() call
+  // in noexcept specification.
+  using namespace std;
+
   template<class T>
   BOOST_GPU_ENABLED
-  void swap_impl(T& left, T& right)
+  void swap_impl(T& left, T& right) BOOST_CORE_SWAP_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(swap(left, right)))
   {
-    using namespace std;//use std::swap if argument dependent lookup fails
-    swap(left,right);
+    swap(left, right);
   }
 
   template<class T, std::size_t N>
   BOOST_GPU_ENABLED
   void swap_impl(T (& left)[N], T (& right)[N])
+    BOOST_CORE_SWAP_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(::boost_swap_impl::swap_impl(left[0], right[0])))
   {
     for (std::size_t i = 0; i < N; ++i)
     {
@@ -62,9 +78,12 @@ namespace boost
   BOOST_GPU_ENABLED
   typename enable_if_c< !boost_swap_impl::is_const<T1>::value && !boost_swap_impl::is_const<T2>::value >::type
   swap(T1& left, T2& right)
+    BOOST_CORE_SWAP_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(::boost_swap_impl::swap_impl(left, right)))
   {
     ::boost_swap_impl::swap_impl(left, right);
   }
 }
 
-#endif
+#undef BOOST_CORE_SWAP_NOEXCEPT_IF
+
+#endif // BOOST_CORE_SWAP_HPP

test/Jamfile.v2

@@ -352,5 +352,9 @@ run-fail verbose_terminate_handler_fail.cpp : : : <exception-handling>off : verb
 run-fail verbose_terminate_handler_fail.cpp : : : <rtti>off : verbose_terminate_handler_fail_nr ;
 run-fail verbose_terminate_handler_fail.cpp : : : <exception-handling>off <rtti>off : verbose_terminate_handler_fail_nxr ;
 
+run launder_test.cpp ;
+
+run alignof_test.cpp ;
+
 use-project /boost/core/swap : ./swap ;
 build-project ./swap ;

test/alignof_test.cpp

@@ -0,0 +1,98 @@
+// Copyright 2023 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/alignof.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/type_traits.hpp>
+#include <boost/config.hpp>
+#include <cstddef>
+
+template<class T> struct struct_of
+{
+    T t;
+};
+
+template<class T> union union_of
+{
+    T t;
+};
+
+template<class T> void test2()
+{
+    BOOST_TEST_EQ( BOOST_CORE_ALIGNOF(T), boost::alignment_of<T>::value );
+
+#if !defined(BOOST_NO_CXX11_ALIGNOF)
+
+    BOOST_TEST_EQ( BOOST_CORE_ALIGNOF(T), alignof(T) );
+
+#endif
+}
+
+template<class T> void test()
+{
+    test2<T>();
+    test2<T[2]>();
+    test2< struct_of<T> >();
+    test2< union_of<T> >();
+}
+
+struct X
+{
+};
+
+int main()
+{
+    test<char>();
+    test<short>();
+    test<int>();
+    test<long>();
+
+#if !defined(BOOST_NO_LONG_LONG)
+# if !( defined(__GNUC__) && defined(__i386__) )
+
+    // g++ -m32 has alignof(long long) = 8, but boost::alignment_of<long long>::value = 4
+    test<boost::long_long_type>();
+
+# endif
+#endif
+
+#if defined(BOOST_HAS_INT128)
+
+    test<boost::int128_type>();
+
+#endif
+
+    test<float>();
+
+#if !( defined(__GNUC__) && defined(__i386__) )
+
+    // g++ -m32 has alignof(double) = 8, but boost::alignment_of<double>::value = 4
+    test<double>();
+
+#endif
+
+    test<long double>();
+
+#if defined(BOOST_HAS_FLOAT128)
+
+    test<__float128>();
+
+#endif
+
+    test<void*>();
+    test<void(*)()>();
+
+#if !defined(_MSC_VER)
+
+    // under MSVC, alignof is 8, boost::alignment_of is 4
+    // under clang-cl, alignof is 4, boost::alignment_of is 8 (!)
+
+    test<int X::*>();
+
+#endif
+
+    test<void (X::*)()>();
+
+    return boost::report_errors();
+}

test/alloc_construct_cxx11_test.cpp

@@ -72,6 +72,7 @@ int main()
     BOOST_TEST_EQ(p->value(), 2);
     boost::alloc_destroy(a, p);
     BOOST_TEST_EQ(type::count, 0);
+    a.deallocate(p, 1);
     return boost::report_errors();
 }
 #else

test/launder_test.cpp

@@ -0,0 +1,34 @@
+// Copyright 2023 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/launder.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <new>
+
+struct X
+{
+    int v_;
+
+    explicit X( int v = 0 ): v_( v ) {}
+};
+
+int main()
+{
+    X x;
+
+    typedef X const CX;
+
+    ::new( &x ) CX( 1 );
+    X const* px1 = &x;
+
+    BOOST_TEST_EQ( px1->v_, 1 );
+
+    ::new( &x ) CX( 2 );
+    X const* px2 = boost::core::launder( px1 );
+
+    BOOST_TEST_EQ( px1, px2 );
+    BOOST_TEST_EQ( px2->v_, 2 );
+
+    return boost::report_errors();
+}

test/swap/Jamfile.v2

@@ -13,6 +13,7 @@ compile swap_lib_header_1.cpp ;
 compile swap_lib_header_2.cpp ;
 compile swap_mixed_headers_1.cpp ;
 compile swap_mixed_headers_2.cpp ;
+compile swap_noexcept.cpp ;
 
 compile-fail swap_const_wrapper_fail.cpp ;
 

test/swap/swap_array_of_class.cpp

@@ -46,13 +46,13 @@ int main()
   const std::size_t array_size = 2;
   const swap_test_class initial_array1[array_size] = { swap_test_class(1), swap_test_class(2) };
   const swap_test_class initial_array2[array_size] = { swap_test_class(3), swap_test_class(4) };
-  
+
   swap_test_class array1[array_size];
   swap_test_class array2[array_size];
 
   std::copy(initial_array1, initial_array1 + array_size, array1);
   std::copy(initial_array2, initial_array2 + array_size, array2);
-  
+
   swap_test_class::reset();
   boost::swap(array1, array2);
 

test/swap/swap_array_of_int.cpp

@@ -20,13 +20,13 @@ int main()
   const std::size_t array_size = 3;
   const int initial_array1[array_size] = { 1, 2, 3 };
   const int initial_array2[array_size] = { 4, 5, 6 };
-  
+
   int array1[array_size];
   int array2[array_size];
 
   std::copy(initial_array1, initial_array1 + array_size, array1);
   std::copy(initial_array2, initial_array2 + array_size, array2);
-  
+
   boost::swap(array1, array2);
 
   BOOST_CHECK(std::equal(array1, array1 + array_size, initial_array2));

test/swap/swap_array_of_template.cpp

@@ -52,13 +52,13 @@ int main()
   const std::size_t array_size = 2;
   const swap_test_template<int> initial_array1[array_size] = { { swap_test_class(1) }, { swap_test_class(2) } };
   const swap_test_template<int> initial_array2[array_size] = { { swap_test_class(3) }, { swap_test_class(4) } };
-  
+
   swap_test_template<int> array1[array_size];
   swap_test_template<int> array2[array_size];
 
   std::copy(initial_array1, initial_array1 + array_size, array1);
   std::copy(initial_array2, initial_array2 + array_size, array2);
-  
+
   swap_test_class::reset();
   boost::swap(array1, array2);
 

test/swap/swap_const_wrapper_fail.cpp

@@ -6,7 +6,7 @@
 
 namespace boost
 {
-  
+
 template<class T> struct Wrapper
 {
     T value;
@@ -16,9 +16,9 @@ template<class T> inline void swap( Wrapper<T> & w, Wrapper<T> & v )
 {
     boost::swap( w, v );
 }
-  
+
 } // namespace boost
- 
+
 int main()
 {
     boost::Wrapper<int> const w = { 2 };

test/swap/swap_noexcept.cpp

@@ -0,0 +1,42 @@
+// Copyright (c) 2023 Andrey Semashev
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// Tests that boost::swap propagates noexcept specification correctly
+
+#include <boost/core/swap.hpp>
+#include <boost/config.hpp>
+
+#if !defined(BOOST_NO_CXX11_NOEXCEPT) && !defined(BOOST_NO_CXX11_STATIC_ASSERT) && \
+    !(defined(BOOST_GCC) && (BOOST_GCC < 40700))
+
+namespace test_ns {
+
+struct class_with_noexcept_swap
+{
+    static class_with_noexcept_swap& instance() noexcept;
+
+    friend void swap(class_with_noexcept_swap&, class_with_noexcept_swap&) noexcept
+    {
+    }
+};
+
+struct class_with_except_swap
+{
+    static class_with_except_swap& instance() noexcept;
+
+    friend void swap(class_with_except_swap&, class_with_except_swap&)
+    {
+    }
+};
+
+} // namespace test_ns
+
+static_assert(noexcept(boost::swap(test_ns::class_with_noexcept_swap::instance(), test_ns::class_with_noexcept_swap::instance())),
+    "boost::swap for class_with_noexcept_swap should have noexcept specification");
+static_assert(!noexcept(boost::swap(test_ns::class_with_except_swap::instance(), test_ns::class_with_except_swap::instance())),
+    "boost::swap for class_with_except_swap should not have noexcept specification");
+
+#endif // !defined(BOOST_NO_CXX11_NOEXCEPT) && !defined(BOOST_NO_CXX11_STATIC_ASSERT) ...

test/swap/swap_specialized_in_boost.cpp

@@ -31,7 +31,7 @@ int main()
 
   boost::swap_test_class object1 = initial_value1;
   boost::swap_test_class object2 = initial_value2;
-  
+
   boost::swap_test_class::reset();
   boost::swap(object1,object2);
 

test/swap/swap_specialized_in_boost_and_other.cpp

@@ -10,7 +10,7 @@
 // in an other namespace to have a custom swap function in boost, because the
 // boost::swap utility should find the swap function in the other namespace, by
 // argument dependent lookup (ADL). Unfortunately ADL isn't fully implemented
-// by some specific compiler versions, including Intel C++ 8.1, MSVC 7.1, and 
+// by some specific compiler versions, including Intel C++ 8.1, MSVC 7.1, and
 // Borland 5.9.3. Users of those compilers might consider adding a swap overload
 // to the boost namespace.
 
@@ -50,13 +50,13 @@ int main()
 
   other::swap_test_class object1 = initial_value1;
   other::swap_test_class object2 = initial_value2;
-  
+
   other::swap_test_class::reset();
   boost::swap(object1,object2);
 
   BOOST_CHECK(object1 == initial_value2);
   BOOST_CHECK(object2 == initial_value1);
-  
+
   BOOST_CHECK_EQUAL(other::swap_test_class::swap_count(),1);
   BOOST_CHECK_EQUAL(other::swap_test_class::copy_count(),0);
 

test/swap/swap_specialized_in_global.cpp

@@ -25,13 +25,13 @@ int main()
 
   swap_test_class object1 = initial_value1;
   swap_test_class object2 = initial_value2;
-  
+
   swap_test_class::reset();
   boost::swap(object1,object2);
 
   BOOST_CHECK(object1 == initial_value2);
   BOOST_CHECK(object2 == initial_value1);
-  
+
   BOOST_CHECK_EQUAL(swap_test_class::swap_count(),1);
   BOOST_CHECK_EQUAL(swap_test_class::copy_count(),0);
 

test/swap/swap_specialized_in_other.cpp

@@ -31,13 +31,13 @@ int main()
 
   other::swap_test_class object1 = initial_value1;
   other::swap_test_class object2 = initial_value2;
-  
+
   other::swap_test_class::reset();
   boost::swap(object1,object2);
 
   BOOST_CHECK(object1 == initial_value2);
   BOOST_CHECK(object2 == initial_value1);
-  
+
   BOOST_CHECK_EQUAL(other::swap_test_class::swap_count(),1);
   BOOST_CHECK_EQUAL(other::swap_test_class::copy_count(),0);
 

test/swap/swap_specialized_in_std.cpp

@@ -30,13 +30,13 @@ int main()
 
   swap_test_class object1 = initial_value1;
   swap_test_class object2 = initial_value2;
-  
+
   swap_test_class::reset();
   boost::swap(object1,object2);
 
   BOOST_CHECK(object1 == initial_value2);
   BOOST_CHECK(object2 == initial_value1);
-  
+
   BOOST_CHECK_EQUAL(swap_test_class::swap_count(),1);
   BOOST_CHECK_EQUAL(swap_test_class::copy_count(),0);
 

test/swap/swap_std_typeinfo_ptr.cpp

@@ -19,7 +19,7 @@ int main()
 {
   const std::type_info * const initial_value1 = 0;
   const std::type_info * const initial_value2 = &typeid(double);
-  
+
   const std::type_info * ptr1 = initial_value1;
   const std::type_info * ptr2 = initial_value2;
 

test/swap/swap_std_vector_of_boost.cpp

@@ -5,7 +5,7 @@
 // http://www.boost.org/LICENSE_1_0.txt)
 
 // Tests swapping std::vector objects by means of boost::swap,
-// having boost::swap_test_class as vector element type. 
+// having boost::swap_test_class as vector element type.
 
 #include <boost/utility/swap.hpp>
 #include <boost/core/lightweight_test.hpp>
@@ -39,12 +39,12 @@ int main()
 
   const vector_type initial_value1(initial_size1, swap_test_class_type(1));
   const vector_type initial_value2(initial_size2, swap_test_class_type(2));
-  
+
   vector_type object1 = initial_value1;
   vector_type object2 = initial_value2;
 
   swap_test_class_type::reset();
-  
+
   boost::swap(object1,object2);
 
   BOOST_CHECK_EQUAL(object1.size(),initial_size2);
@@ -52,7 +52,7 @@ int main()
 
   BOOST_CHECK(object1 == initial_value2);
   BOOST_CHECK(object2 == initial_value1);
-  
+
   BOOST_CHECK_EQUAL(swap_test_class_type::swap_count(),0);
   BOOST_CHECK_EQUAL(swap_test_class_type::copy_count(),0);
 

test/swap/swap_std_vector_of_global.cpp

@@ -5,7 +5,7 @@
 // http://www.boost.org/LICENSE_1_0.txt)
 
 // Tests swapping std::vector objects by means of boost::swap,
-// having ::swap_test_class as vector element type. 
+// having ::swap_test_class as vector element type.
 
 #include <boost/utility/swap.hpp>
 #include <boost/core/lightweight_test.hpp>
@@ -17,7 +17,7 @@
 //Put test class in the global namespace
 #include "./swap_test_class.hpp"
 
-//Provide swap function in the global namespace 
+//Provide swap function in the global namespace
 void swap(swap_test_class& left, swap_test_class& right)
 {
   left.swap(right);
@@ -32,12 +32,12 @@ int main()
 
   const vector_type initial_value1(initial_size1, swap_test_class(1));
   const vector_type initial_value2(initial_size2, swap_test_class(2));
-  
+
   vector_type object1 = initial_value1;
   vector_type object2 = initial_value2;
 
   swap_test_class::reset();
-  
+
   boost::swap(object1,object2);
 
   BOOST_CHECK_EQUAL(object1.size(),initial_size2);

test/swap/swap_std_vector_of_other.cpp

@@ -5,7 +5,7 @@
 // http://www.boost.org/LICENSE_1_0.txt)
 
 // Tests swapping std::vector objects by means of boost::swap,
-// having other::swap_test_class as vector element type. 
+// having other::swap_test_class as vector element type.
 
 #include <boost/utility/swap.hpp>
 #include <boost/core/lightweight_test.hpp>
@@ -39,12 +39,12 @@ int main()
 
   const vector_type initial_value1(initial_size1, swap_test_class_type(1));
   const vector_type initial_value2(initial_size2, swap_test_class_type(2));
-  
+
   vector_type object1 = initial_value1;
   vector_type object2 = initial_value2;
 
   swap_test_class_type::reset();
-  
+
   boost::swap(object1,object2);
 
   BOOST_CHECK_EQUAL(object1.size(),initial_size2);

test/swap/swap_test_class.hpp

@@ -59,7 +59,7 @@ public:
   {
     m_data = arg;
   }
-  
+
   static unsigned int swap_count(){ return swapCount(); }
   static unsigned int copy_count(){ return copyCount(); }
   static unsigned int construct_count(){ return constructCount(); }
@@ -68,7 +68,7 @@ public:
   static void reset()
   {
     swapCount() = 0;
-    copyCount() = 0;    
+    copyCount() = 0;
     constructCount() = 0;
     destructCount() = 0;
   }
@@ -80,19 +80,19 @@ private:
     return value;
   }
 
-  static unsigned int& copyCount()    
+  static unsigned int& copyCount()
   {
     static unsigned int value = 0;
     return value;
   }
 
-  static unsigned int& constructCount()    
+  static unsigned int& constructCount()
   {
     static unsigned int value = 0;
     return value;
   }
 
-  static unsigned int& destructCount()    
+  static unsigned int& destructCount()
   {
     static unsigned int value = 0;
     return value;