Mock Version: 3.0
Mock Version: 3.0
Mock Version: 3.0
ENTER ['do_with_status'](['bash', '--login', '-c', '/usr/bin/rpmbuild -bs --target riscv64 --nodeps /builddir/build/SPECS/kakoune.spec'], chrootPath='/var/lib/mock/f38-build-side-42-init-devel-558124-25838/root'env={'TERM': 'vt100', 'SHELL': '/bin/bash', 'HOME': '/builddir', 'HOSTNAME': 'mock', 'PATH': '/usr/bin:/bin:/usr/sbin:/sbin', 'PROMPT_COMMAND': 'printf "\\033]0;<mock-chroot>\\007"', 'PS1': '<mock-chroot> \\s-\\v\\$ ', 'LANG': 'C.UTF-8'}shell=Falselogger=<mockbuild.trace_decorator.getLog object at 0x3fe5997970>timeout=864000uid=996gid=135user='mockbuild'nspawn_args=[]unshare_net=TrueprintOutput=False)
Executing command: ['bash', '--login', '-c', '/usr/bin/rpmbuild -bs --target riscv64 --nodeps /builddir/build/SPECS/kakoune.spec'] with env {'TERM': 'vt100', 'SHELL': '/bin/bash', 'HOME': '/builddir', 'HOSTNAME': 'mock', 'PATH': '/usr/bin:/bin:/usr/sbin:/sbin', 'PROMPT_COMMAND': 'printf "\\033]0;<mock-chroot>\\007"', 'PS1': '<mock-chroot> \\s-\\v\\$ ', 'LANG': 'C.UTF-8'} and shell False
Building target platforms: riscv64
Building for target riscv64
setting SOURCE_DATE_EPOCH=1678147200
Wrote: /builddir/build/SRPMS/kakoune-2022.10.31-4.fc38.src.rpm
Child return code was: 0
ENTER ['do_with_status'](['bash', '--login', '-c', '/usr/bin/rpmbuild -bb --target riscv64 --nodeps /builddir/build/SPECS/kakoune.spec'], chrootPath='/var/lib/mock/f38-build-side-42-init-devel-558124-25838/root'env={'TERM': 'vt100', 'SHELL': '/bin/bash', 'HOME': '/builddir', 'HOSTNAME': 'mock', 'PATH': '/usr/bin:/bin:/usr/sbin:/sbin', 'PROMPT_COMMAND': 'printf "\\033]0;<mock-chroot>\\007"', 'PS1': '<mock-chroot> \\s-\\v\\$ ', 'LANG': 'C.UTF-8'}shell=Falselogger=<mockbuild.trace_decorator.getLog object at 0x3fe5997970>timeout=864000uid=996gid=135user='mockbuild'nspawn_args=[]unshare_net=TrueprintOutput=False)
Executing command: ['bash', '--login', '-c', '/usr/bin/rpmbuild -bb --target riscv64 --nodeps /builddir/build/SPECS/kakoune.spec'] with env {'TERM': 'vt100', 'SHELL': '/bin/bash', 'HOME': '/builddir', 'HOSTNAME': 'mock', 'PATH': '/usr/bin:/bin:/usr/sbin:/sbin', 'PROMPT_COMMAND': 'printf "\\033]0;<mock-chroot>\\007"', 'PS1': '<mock-chroot> \\s-\\v\\$ ', 'LANG': 'C.UTF-8'} and shell False
Building target platforms: riscv64
Building for target riscv64
setting SOURCE_DATE_EPOCH=1678147200
Executing(%prep): /bin/sh -e /var/tmp/rpm-tmp.PDRckg
+ umask 022
+ cd /builddir/build/BUILD
+ cd /builddir/build/BUILD
+ rm -rf kakoune-2022.10.31
+ /usr/lib/rpm/rpmuncompress -x /builddir/build/SOURCES/kakoune-2022.10.31.tar.gz
+ STATUS=0
+ '[' 0 -ne 0 ']'
+ cd kakoune-2022.10.31
+ /usr/bin/chmod -Rf a+rX,u+w,g-w,o-w .
+ /usr/lib/rpm/rpmuncompress /builddir/build/SOURCES/Fix-New-gcc-errors-for-missing-types.patch
+ /usr/bin/patch -p1 -s --fuzz=0 --no-backup-if-mismatch -f
+ sed -i '/CXXFLAGS += -O3/d' src/Makefile
+ sed -i 's|$(PREFIX)/share/doc/kak|$(PREFIX)/share/doc/kakoune|' src/Makefile
+ RPM_EC=0
++ jobs -p
+ exit 0
Executing(%build): /bin/sh -e /var/tmp/rpm-tmp.Twdlpb
+ umask 022
+ cd /builddir/build/BUILD
+ CFLAGS='-O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer '
+ export CFLAGS
+ CXXFLAGS='-O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer '
+ export CXXFLAGS
+ FFLAGS='-O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer -I/usr/lib64/gfortran/modules '
+ export FFLAGS
+ FCFLAGS='-O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer -I/usr/lib64/gfortran/modules '
+ export FCFLAGS
+ VALAFLAGS=-g
+ export VALAFLAGS
+ LDFLAGS='-Wl,-z,relro -Wl,--as-needed  -Wl,-z,now -specs=/usr/lib/rpm/redhat/redhat-hardened-ld -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -Wl,--build-id=sha1 -specs=/usr/lib/rpm/redhat/redhat-package-notes '
+ export LDFLAGS
+ LT_SYS_LIBRARY_PATH=/usr/lib64:
+ export LT_SYS_LIBRARY_PATH
+ CC=gcc
+ export CC
+ CXX=g++
+ export CXX
+ cd kakoune-2022.10.31
+ CFLAGS='-O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer '
+ export CFLAGS
+ CXXFLAGS='-O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer '
+ export CXXFLAGS
+ FFLAGS='-O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer -I/usr/lib64/gfortran/modules '
+ export FFLAGS
+ FCFLAGS='-O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer -I/usr/lib64/gfortran/modules '
+ export FCFLAGS
+ VALAFLAGS=-g
+ export VALAFLAGS
+ LDFLAGS='-Wl,-z,relro -Wl,--as-needed  -Wl,-z,now -specs=/usr/lib/rpm/redhat/redhat-hardened-ld -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -Wl,--build-id=sha1 -specs=/usr/lib/rpm/redhat/redhat-package-notes '
+ export LDFLAGS
+ LT_SYS_LIBRARY_PATH=/usr/lib64:
+ export LT_SYS_LIBRARY_PATH
+ CC=gcc
+ export CC
+ CXX=g++
+ export CXX
+ /usr/bin/make -O -j8 V=1 VERBOSE=1 -C src
make: Entering directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
g++  -O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer  -pedantic -std=c++2a -g -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-address -Wno-init-list-lifetime -MD -MP -MF .backtrace.opt.d -c -o .backtrace.opt.o backtrace.cc
make: Leaving directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
make: Entering directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
g++  -O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer  -pedantic -std=c++2a -g -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-address -Wno-init-list-lifetime -MD -MP -MF .alias_registry.opt.d -c -o .alias_registry.opt.o alias_registry.cc
make: Leaving directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
make: Entering directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
g++  -O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer  -pedantic -std=c++2a -g -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-address -Wno-init-list-lifetime -MD -MP -MF .changes.opt.d -c -o .changes.opt.o changes.cc
make: Leaving directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
In file included from buffer.hh:310,
                 from changes.hh:4,
                 from changes.cc:1:
buffer.inl.hh: In member function 'Kakoune::ByteCount Kakoune::Buffer::distance(Kakoune::BufferCoord, Kakoune::BufferCoord) const':
buffer.inl.hh:32:17: warning: C++20 says that these are ambiguous, even though the second is reversed:
   32 |     if (begin > end)
      |                 ^~~
In file included from buffer.hh:5:
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::Buffer::is_end(Kakoune::BufferCoord) const':
buffer.inl.hh:53:27: warning: C++20 says that these are ambiguous, even though the second is reversed:
   53 |     return c >= end_coord();
      |                           ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferIterator&) const':
buffer.inl.hh:107:66: warning: C++20 says that these are ambiguous, even though the second is reversed:
  107 |     return m_buffer == iterator.m_buffer and m_coord == iterator.m_coord;
      |                                                                  ^~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'std::strong_ordering Kakoune::BufferIterator::operator<=>(const Kakoune::BufferIterator&) const':
buffer.inl.hh:113:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
  113 |     return (m_coord <=> iterator.m_coord);
      |                                  ^~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferCoord&) const':
buffer.inl.hh:118:23: warning: C++20 says that these are ambiguous, even though the second is reversed:
  118 |     return m_coord == coord;
      |                       ^~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
In file included from units.hh:4,
                 from coord.hh:4:
changes.cc: In member function 'void Kakoune::ForwardChangesTracker::update(const Kakoune::Buffer::Change&)':
changes.cc:7:32: warning: C++20 says that these are ambiguous, even though the second is reversed:
    7 |     kak_assert(change.begin >= cur_pos);
      |                                ^~~~~~~
assert.hh:33:47: note: in definition of macro 'kak_assert'
   33 |     #define kak_assert(...) do { (void)sizeof(__VA_ARGS__); } while(false)
      |                                               ^~~~~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
changes.cc: In member function 'Kakoune::BufferCoord Kakoune::ForwardChangesTracker::get_old_coord(Kakoune::BufferCoord) const':
changes.cc:30:27: warning: C++20 says that these are ambiguous, even though the second is reversed:
   30 |     kak_assert(cur_pos <= coord);
      |                           ^~~~~
assert.hh:33:47: note: in definition of macro 'kak_assert'
   33 |     #define kak_assert(...) do { (void)sizeof(__VA_ARGS__); } while(false)
      |                                               ^~~~~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
changes.cc:38:27: warning: C++20 says that these are ambiguous, even though the second is reversed:
   38 |     kak_assert(old_pos <= coord);
      |                           ^~~~~
assert.hh:33:47: note: in definition of macro 'kak_assert'
   33 |     #define kak_assert(...) do { (void)sizeof(__VA_ARGS__); } while(false)
      |                                               ^~~~~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
changes.cc: In member function 'Kakoune::BufferCoord Kakoune::ForwardChangesTracker::get_new_coord(Kakoune::BufferCoord) const':
changes.cc:44:27: warning: C++20 says that these are ambiguous, even though the second is reversed:
   44 |     kak_assert(old_pos <= coord);
      |                           ^~~~~
assert.hh:33:47: note: in definition of macro 'kak_assert'
   33 |     #define kak_assert(...) do { (void)sizeof(__VA_ARGS__); } while(false)
      |                                               ^~~~~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
changes.cc:52:27: warning: C++20 says that these are ambiguous, even though the second is reversed:
   52 |     kak_assert(cur_pos <= coord);
      |                           ^~~~~
assert.hh:33:47: note: in definition of macro 'kak_assert'
   33 |     #define kak_assert(...) do { (void)sizeof(__VA_ARGS__); } while(false)
      |                                               ^~~~~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
changes.cc: In member function 'Kakoune::BufferCoord Kakoune::ForwardChangesTracker::get_new_coord_tolerant(Kakoune::BufferCoord) const':
changes.cc:58:17: warning: C++20 says that these are ambiguous, even though the second is reversed:
   58 |     if (coord < old_pos)
      |                 ^~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
changes.cc: In member function 'bool Kakoune::ForwardChangesTracker::relevant(const Kakoune::Buffer::Change&, Kakoune::BufferCoord) const':
changes.cc:66:68: warning: C++20 says that these are ambiguous, even though the second is reversed:
   66 |     return change.type == Buffer::Change::Insert ? change.begin <= new_coord
      |                                                                    ^~~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
changes.cc:67:67: warning: C++20 says that these are ambiguous, even though the second is reversed:
   67 |                                                  : change.begin < new_coord;
      |                                                                   ^~~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
changes.cc: In function 'const Kakoune::Buffer::Change* Kakoune::forward_sorted_until(const Buffer::Change*, const Buffer::Change*)':
changes.cc:76:32: warning: C++20 says that these are ambiguous, even though the second is reversed:
   76 |             if (next->begin <= ref)
      |                                ^~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
changes.cc: In function 'const Kakoune::Buffer::Change* Kakoune::backward_sorted_until(const Buffer::Change*, const Buffer::Change*)':
changes.cc:89:38: warning: C++20 says that these are ambiguous, even though the second is reversed:
   89 |             if (first->begin < next->end)
      |                                      ^~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
make: Entering directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
g++  -O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer  -pedantic -std=c++2a -g -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-address -Wno-init-list-lifetime -MD -MP -MF .assert.opt.d -c -o .assert.opt.o assert.cc
make: Leaving directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
In file included from buffer.hh:310,
                 from buffer_utils.hh:4,
                 from assert.cc:4:
buffer.inl.hh: In member function 'Kakoune::ByteCount Kakoune::Buffer::distance(Kakoune::BufferCoord, Kakoune::BufferCoord) const':
buffer.inl.hh:32:17: warning: C++20 says that these are ambiguous, even though the second is reversed:
   32 |     if (begin > end)
      |                 ^~~
In file included from buffer.hh:5:
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::Buffer::is_end(Kakoune::BufferCoord) const':
buffer.inl.hh:53:27: warning: C++20 says that these are ambiguous, even though the second is reversed:
   53 |     return c >= end_coord();
      |                           ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferIterator&) const':
buffer.inl.hh:107:66: warning: C++20 says that these are ambiguous, even though the second is reversed:
  107 |     return m_buffer == iterator.m_buffer and m_coord == iterator.m_coord;
      |                                                                  ^~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'std::strong_ordering Kakoune::BufferIterator::operator<=>(const Kakoune::BufferIterator&) const':
buffer.inl.hh:113:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
  113 |     return (m_coord <=> iterator.m_coord);
      |                                  ^~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferCoord&) const':
buffer.inl.hh:118:23: warning: C++20 says that these are ambiguous, even though the second is reversed:
  118 |     return m_coord == coord;
      |                       ^~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
In file included from buffer_utils.hh:5:
selection.hh: In member function 'bool Kakoune::Selection::operator==(const Kakoune::Selection&) const':
selection.hh:47:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
   47 |         return m_anchor == other.m_anchor and m_cursor == other.m_cursor;
      |                                  ^~~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'Kakoune::BufferCoord& Kakoune::Selection::min()':
selection.hh:54:45: warning: C++20 says that these are ambiguous, even though the second is reversed:
   54 |     BufferCoord& min() { return m_anchor <= m_cursor ? m_anchor : m_cursor; }
      |                                             ^~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'Kakoune::BufferCoord& Kakoune::Selection::max()':
selection.hh:55:45: warning: C++20 says that these are ambiguous, even though the second is reversed:
   55 |     BufferCoord& max() { return m_anchor <= m_cursor ? m_cursor : m_anchor; }
      |                                             ^~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In function 'bool Kakoune::overlaps(const Selection&, const Selection&)':
selection.hh:66:33: warning: C++20 says that these are ambiguous, even though the second is reversed:
   66 |     return lhs.min() <= rhs.min() ? lhs.max() >= rhs.min()
      |                                 ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh:66:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
   66 |     return lhs.min() <= rhs.min() ? lhs.max() >= rhs.min()
      |                                                          ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh:67:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
   67 |                                   : lhs.min() <= rhs.max();
      |                                                          ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer_utils.hh: In function 'bool Kakoune::is_bow(const Buffer&, BufferCoord)':
buffer_utils.hh:54:33: warning: C++20 says that these are ambiguous, even though the second is reversed:
   54 |     if (coord == BufferCoord{0,0})
      |                                 ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer_utils.hh: In function 'bool Kakoune::is_eow(const Buffer&, BufferCoord)':
buffer_utils.hh:62:57: warning: C++20 says that these are ambiguous, even though the second is reversed:
   62 |     if (buffer.is_end(coord) or coord == BufferCoord{0,0})
      |                                                         ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
make: Entering directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
g++  -O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer  -pedantic -std=c++2a -g -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-address -Wno-init-list-lifetime -MD -MP -MF .color.opt.d -c -o .color.opt.o color.cc
make: Leaving directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
make: Entering directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
g++  -O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer  -pedantic -std=c++2a -g -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-address -Wno-init-list-lifetime -MD -MP -MF .buffer_manager.opt.d -c -o .buffer_manager.opt.o buffer_manager.cc
make: Leaving directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
In file included from buffer.hh:310,
                 from buffer_manager.hh:4,
                 from buffer_manager.cc:1:
buffer.inl.hh: In member function 'Kakoune::ByteCount Kakoune::Buffer::distance(Kakoune::BufferCoord, Kakoune::BufferCoord) const':
buffer.inl.hh:32:17: warning: C++20 says that these are ambiguous, even though the second is reversed:
   32 |     if (begin > end)
      |                 ^~~
In file included from buffer.hh:5:
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::Buffer::is_end(Kakoune::BufferCoord) const':
buffer.inl.hh:53:27: warning: C++20 says that these are ambiguous, even though the second is reversed:
   53 |     return c >= end_coord();
      |                           ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferIterator&) const':
buffer.inl.hh:107:66: warning: C++20 says that these are ambiguous, even though the second is reversed:
  107 |     return m_buffer == iterator.m_buffer and m_coord == iterator.m_coord;
      |                                                                  ^~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'std::strong_ordering Kakoune::BufferIterator::operator<=>(const Kakoune::BufferIterator&) const':
buffer.inl.hh:113:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
  113 |     return (m_coord <=> iterator.m_coord);
      |                                  ^~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferCoord&) const':
buffer.inl.hh:118:23: warning: C++20 says that these are ambiguous, even though the second is reversed:
  118 |     return m_coord == coord;
      |                       ^~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
In file included from context.hh:4,
                 from input_handler.hh:6,
                 from client.hh:7,
                 from client_manager.hh:4,
                 from buffer_manager.cc:5:
selection.hh: In member function 'bool Kakoune::Selection::operator==(const Kakoune::Selection&) const':
selection.hh:47:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
   47 |         return m_anchor == other.m_anchor and m_cursor == other.m_cursor;
      |                                  ^~~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'Kakoune::BufferCoord& Kakoune::Selection::min()':
selection.hh:54:45: warning: C++20 says that these are ambiguous, even though the second is reversed:
   54 |     BufferCoord& min() { return m_anchor <= m_cursor ? m_anchor : m_cursor; }
      |                                             ^~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'Kakoune::BufferCoord& Kakoune::Selection::max()':
selection.hh:55:45: warning: C++20 says that these are ambiguous, even though the second is reversed:
   55 |     BufferCoord& max() { return m_anchor <= m_cursor ? m_cursor : m_anchor; }
      |                                             ^~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In function 'bool Kakoune::overlaps(const Selection&, const Selection&)':
selection.hh:66:33: warning: C++20 says that these are ambiguous, even though the second is reversed:
   66 |     return lhs.min() <= rhs.min() ? lhs.max() >= rhs.min()
      |                                 ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh:66:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
   66 |     return lhs.min() <= rhs.min() ? lhs.max() >= rhs.min()
      |                                                          ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh:67:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
   67 |                                   : lhs.min() <= rhs.max();
      |                                                          ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
make: Entering directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
g++  -O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer  -pedantic -std=c++2a -g -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-address -Wno-init-list-lifetime -MD -MP -MF .buffer_utils.opt.d -c -o .buffer_utils.opt.o buffer_utils.cc
In file included from buffer.hh:310,
                 from buffer_utils.hh:4,
                 from buffer_utils.cc:1:
buffer.inl.hh: In member function 'Kakoune::ByteCount Kakoune::Buffer::distance(Kakoune::BufferCoord, Kakoune::BufferCoord) const':
buffer.inl.hh:32:17: warning: C++20 says that these are ambiguous, even though the second is reversed:
   32 |     if (begin > end)
      |                 ^~~
In file included from buffer.hh:5:
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::Buffer::is_end(Kakoune::BufferCoord) const':
buffer.inl.hh:53:27: warning: C++20 says that these are ambiguous, even though the second is reversed:
   53 |     return c >= end_coord();
      |                           ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferIterator&) const':
buffer.inl.hh:107:66: warning: C++20 says that these are ambiguous, even though the second is reversed:
  107 |     return m_buffer == iterator.m_buffer and m_coord == iterator.m_coord;
      |                                                                  ^~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'std::strong_ordering Kakoune::BufferIterator::operator<=>(const Kakoune::BufferIterator&) const':
buffer.inl.hh:113:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
  113 |     return (m_coord <=> iterator.m_coord);
      |                                  ^~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferCoord&) const':
buffer.inl.hh:118:23: warning: C++20 says that these are ambiguous, even though the second is reversed:
  118 |     return m_coord == coord;
      |                       ^~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
In file included from buffer_utils.hh:5:
selection.hh: In member function 'bool Kakoune::Selection::operator==(const Kakoune::Selection&) const':
selection.hh:47:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
   47 |         return m_anchor == other.m_anchor and m_cursor == other.m_cursor;
      |                                  ^~~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'Kakoune::BufferCoord& Kakoune::Selection::min()':
selection.hh:54:45: warning: C++20 says that these are ambiguous, even though the second is reversed:
   54 |     BufferCoord& min() { return m_anchor <= m_cursor ? m_anchor : m_cursor; }
      |                                             ^~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'Kakoune::BufferCoord& Kakoune::Selection::max()':
selection.hh:55:45: warning: C++20 says that these are ambiguous, even though the second is reversed:
   55 |     BufferCoord& max() { return m_anchor <= m_cursor ? m_cursor : m_anchor; }
      |                                             ^~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In function 'bool Kakoune::overlaps(const Selection&, const Selection&)':
selection.hh:66:33: warning: C++20 says that these are ambiguous, even though the second is reversed:
   66 |     return lhs.min() <= rhs.min() ? lhs.max() >= rhs.min()
      |                                 ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnTmake: Leaving directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
ype>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh:66:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
   66 |     return lhs.min() <= rhs.min() ? lhs.max() >= rhs.min()
      |                                                          ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh:67:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
   67 |                                   : lhs.min() <= rhs.max();
      |                                                          ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer_utils.hh: In function 'bool Kakoune::is_bow(const Buffer&, BufferCoord)':
buffer_utils.hh:54:33: warning: C++20 says that these are ambiguous, even though the second is reversed:
   54 |     if (coord == BufferCoord{0,0})
      |                                 ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer_utils.hh: In function 'bool Kakoune::is_eow(const Buffer&, BufferCoord)':
buffer_utils.hh:62:57: warning: C++20 says that these are ambiguous, even though the second is reversed:
   62 |     if (buffer.is_end(coord) or coord == BufferCoord{0,0})
      |                                                         ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer_utils.cc: In member function 'void Kakoune::create_fifo_buffer(String, int, Buffer::Flags, bool)::FifoWatcher::read_fifo() const':
buffer_utils.cc:236:74: warning: C++20 says that these are ambiguous, even though the second is reversed:
  236 |                     const bool prevent_scrolling = pos == BufferCoord{0,0} and not m_scroll;
      |                                                                          ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer_utils.cc:254:53: warning: C++20 says that these are ambiguous, even though the second is reversed:
  254 |             if (insert_coord != m_buffer.back_coord())
      |                                                     ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
make: Entering directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
g++  -O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer  -pedantic -std=c++2a -g -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-address -Wno-init-list-lifetime -MD -MP -MF .client.opt.d -c -o .client.opt.o client.cc
make: Leaving directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
In file included from buffer.hh:310,
                 from selection.hh:4,
                 from context.hh:4,
                 from input_handler.hh:6,
                 from client.hh:7,
                 from client.cc:1:
buffer.inl.hh: In member function 'Kakoune::ByteCount Kakoune::Buffer::distance(Kakoune::BufferCoord, Kakoune::BufferCoord) const':
buffer.inl.hh:32:17: warning: C++20 says that these are ambiguous, even though the second is reversed:
   32 |     if (begin > end)
      |                 ^~~
In file included from display_buffer.hh:6,
                 from client.hh:5:
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::Buffer::is_end(Kakoune::BufferCoord) const':
buffer.inl.hh:53:27: warning: C++20 says that these are ambiguous, even though the second is reversed:
   53 |     return c >= end_coord();
      |                           ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferIterator&) const':
buffer.inl.hh:107:66: warning: C++20 says that these are ambiguous, even though the second is reversed:
  107 |     return m_buffer == iterator.m_buffer and m_coord == iterator.m_coord;
      |                                                                  ^~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'std::strong_ordering Kakoune::BufferIterator::operator<=>(const Kakoune::BufferIterator&) const':
buffer.inl.hh:113:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
  113 |     return (m_coord <=> iterator.m_coord);
      |                                  ^~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferCoord&) const':
buffer.inl.hh:118:23: warning: C++20 says that these are ambiguous, even though the second is reversed:
  118 |     return m_coord == coord;
      |                       ^~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'bool Kakoune::Selection::operator==(const Kakoune::Selection&) const':
selection.hh:47:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
   47 |         return m_anchor == other.m_anchor and m_cursor == other.m_cursor;
      |                                  ^~~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'Kakoune::BufferCoord& Kakoune::Selection::min()':
selection.hh:54:45: warning: C++20 says that these are ambiguous, even though the second is reversed:
   54 |     BufferCoord& min() { return m_anchor <= m_cursor ? m_anchor : m_cursor; }
      |                                             ^~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'Kakoune::BufferCoord& Kakoune::Selection::max()':
selection.hh:55:45: warning: C++20 says that these are ambiguous, even though the second is reversed:
   55 |     BufferCoord& max() { return m_anchor <= m_cursor ? m_cursor : m_anchor; }
      |                                             ^~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In function 'bool Kakoune::overlaps(const Selection&, const Selection&)':
selection.hh:66:33: warning: C++20 says that these are ambiguous, even though the second is reversed:
   66 |     return lhs.min() <= rhs.min() ? lhs.max() >= rhs.min()
      |                                 ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh:66:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
   66 |     return lhs.min() <= rhs.min() ? lhs.max() >= rhs.min()
      |                                                          ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh:67:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
   67 |                                   : lhs.min() <= rhs.max();
      |                                                          ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
In file included from client.cc:6:
buffer_utils.hh: In function 'bool Kakoune::is_bow(const Buffer&, BufferCoord)':
buffer_utils.hh:54:33: warning: C++20 says that these are ambiguous, even though the second is reversed:
   54 |     if (coord == BufferCoord{0,0})
      |                                 ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer_utils.hh: In function 'bool Kakoune::is_eow(const Buffer&, BufferCoord)':
buffer_utils.hh:62:57: warning: C++20 says that these are ambiguous, even though the second is reversed:
   62 |     if (buffer.is_end(coord) or coord == BufferCoord{0,0})
      |                                                         ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
In file included from utf8.hh:7,
                 from string.hh:7,
                 from exception.hh:4,
                 from color.hh:4,
                 from face.hh:4,
                 from display_buffer.hh:4:
optional.hh: In instantiation of 'bool Kakoune::Optional<T>::operator==(const Kakoune::Optional<T>&) const [with T = Kakoune::DisplayCoord]':
optional.hh:60:67:   required from 'bool Kakoune::Optional<T>::operator!=(const Kakoune::Optional<T>&) const [with T = Kakoune::DisplayCoord]'
client.cc:233:67:   required from here
optional.hh:57:40: warning: C++20 says that these are ambiguous, even though the second is reversed:
   57 |                (not m_valid or m_value == other.m_value);
      |                                ~~~~~~~~^~~~~~~~~~~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::DisplayCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ColumnCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::DisplayCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ColumnCount]' (reversed)
make: Entering directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
g++  -O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer  -pedantic -std=c++2a -g -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-address -Wno-init-list-lifetime -MD -MP -MF .client_manager.opt.d -c -o .client_manager.opt.o client_manager.cc
make: Leaving directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
In file included from buffer.hh:310,
                 from selection.hh:4,
                 from context.hh:4,
                 from input_handler.hh:6,
                 from client.hh:7,
                 from client_manager.hh:4,
                 from client_manager.cc:1:
buffer.inl.hh: In member function 'Kakoune::ByteCount Kakoune::Buffer::distance(Kakoune::BufferCoord, Kakoune::BufferCoord) const':
buffer.inl.hh:32:17: warning: C++20 says that these are ambiguous, even though the second is reversed:
   32 |     if (begin > end)
      |                 ^~~
In file included from display_buffer.hh:6,
                 from client.hh:5:
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::Buffer::is_end(Kakoune::BufferCoord) const':
buffer.inl.hh:53:27: warning: C++20 says that these are ambiguous, even though the second is reversed:
   53 |     return c >= end_coord();
      |                           ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferIterator&) const':
buffer.inl.hh:107:66: warning: C++20 says that these are ambiguous, even though the second is reversed:
  107 |     return m_buffer == iterator.m_buffer and m_coord == iterator.m_coord;
      |                                                                  ^~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'std::strong_ordering Kakoune::BufferIterator::operator<=>(const Kakoune::BufferIterator&) const':
buffer.inl.hh:113:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
  113 |     return (m_coord <=> iterator.m_coord);
      |                                  ^~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferCoord&) const':
buffer.inl.hh:118:23: warning: C++20 says that these are ambiguous, even though the second is reversed:
  118 |     return m_coord == coord;
      |                       ^~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'bool Kakoune::Selection::operator==(const Kakoune::Selection&) const':
selection.hh:47:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
   47 |         return m_anchor == other.m_anchor and m_cursor == other.m_cursor;
      |                                  ^~~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'Kakoune::BufferCoord& Kakoune::Selection::min()':
selection.hh:54:45: warning: C++20 says that these are ambiguous, even though the second is reversed:
   54 |     BufferCoord& min() { return m_anchor <= m_cursor ? m_anchor : m_cursor; }
      |                                             ^~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'Kakoune::BufferCoord& Kakoune::Selection::max()':
selection.hh:55:45: warning: C++20 says that these are ambiguous, even though the second is reversed:
   55 |     BufferCoord& max() { return m_anchor <= m_cursor ? m_cursor : m_anchor; }
      |                                             ^~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In function 'bool Kakoune::overlaps(const Selection&, const Selection&)':
selection.hh:66:33: warning: C++20 says that these are ambiguous, even though the second is reversed:
   66 |     return lhs.min() <= rhs.min() ? lhs.max() >= rhs.min()
      |                                 ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh:66:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
   66 |     return lhs.min() <= rhs.min() ? lhs.max() >= rhs.min()
      |                                                          ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh:67:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
   67 |                                   : lhs.min() <= rhs.max();
      |                                                          ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
make: Entering directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
g++  -O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer  -pedantic -std=c++2a -g -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-address -Wno-init-list-lifetime -MD -MP -MF .completion.opt.d -c -o .completion.opt.o completion.cc
In file included from buffer.hh:310,
                 from selection.hh:4,
                 from context.hh:4,
                 from completion.cc:3:
buffer.inl.hh: In member function 'Kakoune::ByteCount Kakoune::Buffer::distance(Kakoune::BufferCoord, Kakoune::BufferCoord) const':
buffer.inl.hh:32:17: warning: C++20 says that these are ambiguous, even though the second is reversed:
   32 |     if (begin > end)
      |                 ^~~
In file included from buffer.hh:5:
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::Buffer::is_end(Kakoune::BufferCoord) const':
buffer.inl.hh:53:27: warning: C++20 says that these are ambiguous, even though the second is reversed:
   53 |     return c >= end_coord();
      |                           ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferIterator&) const':
buffer.inl.hh:107:66: warning: C++20 says that these are ambiguous, even though the second is reversed:
  107 |     return m_buffer == iterator.m_buffer and m_coord == iterator.m_coord;
      |                                                                  ^~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'std::strong_ordering Kakoune::BufferIterator::operator<=>(const Kakoune::BufferIterator&) const':
buffer.inl.hh:113:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
  113 |     return (m_coord <=> iterator.m_coord);
      |                                  ^~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferCoord&) const':
buffer.inl.hh:118:23: warning: C++20 says that these are ambiguous, even though the second is reversed:
  118 |     return m_coord == coord;
      |                       ^~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'bool Kakoune::Selection::operator==(const Kakoune::Selection&) const':
selection.hh:47:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
   47 |         return m_anchor == other.m_anchor and m_cursor == other.m_cursor;
      |                                  ^~~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'Kakoune::BufferCoord& Kakoune::Selection::min()':
selection.hh:54:45: warning: C++20 says that these are ambiguous, even though the second is reversed:
   54 |     BufferCoord& min() { return m_anchor <= m_cursor ? m_anchor : m_cursor; }
      |                                             ^~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'Kakoune::BufferCoord& Kakoune::Selection::max()':
selection.hh:55:45: warning: C++20 says that these are ambiguous, even though the second is reversed:
   55 |     BufferCoord& max() { return m_anchor <= m_cursor ? m_cursor : m_anchor; }
      |                                             ^~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In function 'bool Kakoune::overlaps(const Selection&, const Selection&)':
selection.hh:66:33: warning: C++20 says that these are ambiguous, even though the second is reversed:
   66 |     return lhs.min() <= rhs.min() ? lhs.max() >= rhs.min()
      |                                 ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::opermake: Leaving directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
ator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh:66:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
   66 |     return lhs.min() <= rhs.min() ? lhs.max() >= rhs.min()
      |                                                          ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh:67:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
   67 |                                   : lhs.min() <= rhs.max();
      |                                                          ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
make: Entering directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
g++  -O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer  -pedantic -std=c++2a -g -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-address -Wno-init-list-lifetime -MD -MP -MF .env_vars.opt.d -c -o .env_vars.opt.o env_vars.cc
make: Leaving directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
make: Entering directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
g++  -O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer  -pedantic -std=c++2a -g -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-address -Wno-init-list-lifetime -MD -MP -MF .buffer.opt.d -c -o .buffer.opt.o buffer.cc
In file included from buffer.hh:310,
                 from buffer.cc:1:
buffer.inl.hh: In member function 'Kakoune::ByteCount Kakoune::Buffer::distance(Kakoune::BufferCoord, Kakoune::BufferCoord) const':
buffer.inl.hh:32:17: warning: C++20 says that these are ambiguous, even though the second is reversed:
   32 |     if (begin > end)
      |                 ^~~
In file included from buffer.hh:5:
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::Buffer::is_end(Kakoune::BufferCoord) const':
buffer.inl.hh:53:27: warning: C++20 says that these are ambiguous, even though the second is reversed:
   53 |     return c >= end_coord();
      |                           ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferIterator&) const':
buffer.inl.hh:107:66: warning: C++20 says that these are ambiguous, even though the second is reversed:
  107 |     return m_buffer == iterator.m_buffer and m_coord == iterator.m_coord;
      |                                                                  ^~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'std::strong_ordering Kakoune::BufferIterator::operator<=>(const Kakoune::BufferIterator&) const':
buffer.inl.hh:113:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
  113 |     return (m_coord <=> iterator.m_coord);
      |                                  ^~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferCoord&) const':
buffer.inl.hh:118:23: warning: C++20 says that these are ambiguous, even though the second is reversed:
  118 |     return m_coord == coord;
      |                       ^~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
In file included from buffer_utils.hh:5,
                 from buffer.cc:5:
selection.hh: In member function 'bool Kakoune::Selection::operator==(const Kakoune::Selection&) const':
selection.hh:47:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
   47 |         return m_anchor == other.m_anchor and m_cursor == other.m_cursor;
      |                                  ^~~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'Kakoune::BufferCoord& Kakoune::Selection::min()':
selection.hh:54:45: warning: C++20 says that these are ambiguous, even though the second is reversed:
   54 |     BufferCoord& min() { return m_anchor <= m_cursor ? m_anchor : m_cursor; }
      |                                             ^~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'Kakoune::BufferCoord& Kakoune::Selection::max()':
selection.hh:55:45: warning: C++20 says that these are ambiguous, even though the second is reversed:
   55 |     BufferCoord& max() { return m_anchor <= m_cursor ? m_cursor : m_anchor; }
      |                                             ^~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In function 'bool Kakoune::overlaps(const Selection&, const Selection&)':
selection.hh:66:33: warning: C++20 says that these are ambiguous, even though the second is reversed:
   66 |     return lhs.min() <= rhs.min() ? lhs.max() >= rhs.min()
      |                                 ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operatmake: Leaving directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
or<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh:66:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
   66 |     return lhs.min() <= rhs.min() ? lhs.max() >= rhs.min()
      |                                                          ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh:67:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
   67 |                                   : lhs.min() <= rhs.max();
      |                                                          ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer_utils.hh: In function 'bool Kakoune::is_bow(const Buffer&, BufferCoord)':
buffer_utils.hh:54:33: warning: C++20 says that these are ambiguous, even though the second is reversed:
   54 |     if (coord == BufferCoord{0,0})
      |                                 ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer_utils.hh: In function 'bool Kakoune::is_eow(const Buffer&, BufferCoord)':
buffer_utils.hh:62:57: warning: C++20 says that these are ambiguous, even though the second is reversed:
   62 |     if (buffer.is_end(coord) or coord == BufferCoord{0,0})
      |                                                         ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.cc: In member function 'Kakoune::BufferCoord Kakoune::Buffer::clamp(Kakoune::BufferCoord) const':
buffer.cc:150:28: warning: C++20 says that these are ambiguous, even though the second is reversed:
  150 |     if (coord > back_coord())
      |                            ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.cc: In member function 'Kakoune::BufferCoord Kakoune::Buffer::do_erase(Kakoune::BufferCoord, Kakoune::BufferCoord)':
buffer.cc:446:18: warning: C++20 says that these are ambiguous, even though the second is reversed:
  446 |     if (begin == end)
      |                  ^~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.cc: In member function 'Kakoune::BufferCoord Kakoune::Buffer::erase(Kakoune::BufferCoord, Kakoune::BufferCoord)':
buffer.cc:514:61: warning: C++20 says that these are ambiguous, even though the second is reversed:
  514 |         end = (begin.column != 0 or begin == BufferCoord{0,0}) ? prev(end) : end_coord();
      |                                                             ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.cc:516:18: warning: C++20 says that these are ambiguous, even though the second is reversed:
  516 |     if (begin >= end) // use >= to handle case where begin is {line_count}
      |                  ^~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
In file included from units.hh:4,
                 from coord.hh:4:
buffer.cc: In lambda function:
buffer.cc:689:47: warning: C++20 says that these are ambiguous, even though the second is reversed:
  689 |     kak_assert(pos.coord() == BufferCoord{0, 6});
      |                                               ^
assert.hh:33:47: note: in definition of macro 'kak_assert'
   33 |     #define kak_assert(...) do { (void)sizeof(__VA_ARGS__); } while(false)
      |                                               ^~~~~~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.cc:691:47: warning: C++20 says that these are ambiguous, even though the second is reversed:
  691 |     kak_assert(pos.coord() == BufferCoord{1, 0});
      |                                               ^
assert.hh:33:47: note: in definition of macro 'kak_assert'
   33 |     #define kak_assert(...) do { (void)sizeof(__VA_ARGS__); } while(false)
      |                                               ^~~~~~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.cc:693:47: warning: C++20 says that these are ambiguous, even though the second is reversed:
  693 |     kak_assert(pos.coord() == BufferCoord{0, 6});
      |                                               ^
assert.hh:33:47: note: in definition of macro 'kak_assert'
   33 |     #define kak_assert(...) do { (void)sizeof(__VA_ARGS__); } while(false)
      |                                               ^~~~~~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.cc:695:47: warning: C++20 says that these are ambiguous, even though the second is reversed:
  695 |     kak_assert(pos.coord() == BufferCoord{1, 0});
      |                                               ^
assert.hh:33:47: note: in definition of macro 'kak_assert'
   33 |     #define kak_assert(...) do { (void)sizeof(__VA_ARGS__); } while(false)
      |                                               ^~~~~~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
make: Entering directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
g++  -O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer  -pedantic -std=c++2a -g -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-address -Wno-init-list-lifetime -MD -MP -MF .exception.opt.d -c -o .exception.opt.o exception.cc
make: Leaving directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
make: Entering directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
g++  -O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer  -pedantic -std=c++2a -g -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-address -Wno-init-list-lifetime -MD -MP -MF .hash.opt.d -c -o .hash.opt.o hash.cc
make: Leaving directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
make: Entering directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
g++  -O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer  -pedantic -std=c++2a -g -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-address -Wno-init-list-lifetime -MD -MP -MF .context.opt.d -c -o .context.opt.o context.cc
make: Leaving directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
In file included from buffer.hh:310,
                 from selection.hh:4,
                 from context.hh:4,
                 from context.cc:1:
buffer.inl.hh: In member function 'Kakoune::ByteCount Kakoune::Buffer::distance(Kakoune::BufferCoord, Kakoune::BufferCoord) const':
buffer.inl.hh:32:17: warning: C++20 says that these are ambiguous, even though the second is reversed:
   32 |     if (begin > end)
      |                 ^~~
In file included from buffer.hh:5:
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::Buffer::is_end(Kakoune::BufferCoord) const':
buffer.inl.hh:53:27: warning: C++20 says that these are ambiguous, even though the second is reversed:
   53 |     return c >= end_coord();
      |                           ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferIterator&) const':
buffer.inl.hh:107:66: warning: C++20 says that these are ambiguous, even though the second is reversed:
  107 |     return m_buffer == iterator.m_buffer and m_coord == iterator.m_coord;
      |                                                                  ^~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'std::strong_ordering Kakoune::BufferIterator::operator<=>(const Kakoune::BufferIterator&) const':
buffer.inl.hh:113:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
  113 |     return (m_coord <=> iterator.m_coord);
      |                                  ^~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferCoord&) const':
buffer.inl.hh:118:23: warning: C++20 says that these are ambiguous, even though the second is reversed:
  118 |     return m_coord == coord;
      |                       ^~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'bool Kakoune::Selection::operator==(const Kakoune::Selection&) const':
selection.hh:47:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
   47 |         return m_anchor == other.m_anchor and m_cursor == other.m_cursor;
      |                                  ^~~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'Kakoune::BufferCoord& Kakoune::Selection::min()':
selection.hh:54:45: warning: C++20 says that these are ambiguous, even though the second is reversed:
   54 |     BufferCoord& min() { return m_anchor <= m_cursor ? m_anchor : m_cursor; }
      |                                             ^~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'Kakoune::BufferCoord& Kakoune::Selection::max()':
selection.hh:55:45: warning: C++20 says that these are ambiguous, even though the second is reversed:
   55 |     BufferCoord& max() { return m_anchor <= m_cursor ? m_cursor : m_anchor; }
      |                                             ^~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In function 'bool Kakoune::overlaps(const Selection&, const Selection&)':
selection.hh:66:33: warning: C++20 says that these are ambiguous, even though the second is reversed:
   66 |     return lhs.min() <= rhs.min() ? lhs.max() >= rhs.min()
      |                                 ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh:66:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
   66 |     return lhs.min() <= rhs.min() ? lhs.max() >= rhs.min()
      |                                                          ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh:67:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
   67 |                                   : lhs.min() <= rhs.max();
      |                                                          ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
make: Entering directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
g++  -O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer  -pedantic -std=c++2a -g -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-address -Wno-init-list-lifetime -MD -MP -MF .display_buffer.opt.d -c -o .display_buffer.opt.o display_buffer.cc
make: Leaving directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
In file included from buffer.hh:310,
                 from display_buffer.cc:4:
buffer.inl.hh: In member function 'Kakoune::ByteCount Kakoune::Buffer::distance(Kakoune::BufferCoord, Kakoune::BufferCoord) const':
buffer.inl.hh:32:17: warning: C++20 says that these are ambiguous, even though the second is reversed:
   32 |     if (begin > end)
      |                 ^~~
In file included from display_buffer.hh:6,
                 from display_buffer.cc:1:
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::Buffer::is_end(Kakoune::BufferCoord) const':
buffer.inl.hh:53:27: warning: C++20 says that these are ambiguous, even though the second is reversed:
   53 |     return c >= end_coord();
      |                           ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferIterator&) const':
buffer.inl.hh:107:66: warning: C++20 says that these are ambiguous, even though the second is reversed:
  107 |     return m_buffer == iterator.m_buffer and m_coord == iterator.m_coord;
      |                                                                  ^~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'std::strong_ordering Kakoune::BufferIterator::operator<=>(const Kakoune::BufferIterator&) const':
buffer.inl.hh:113:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
  113 |     return (m_coord <=> iterator.m_coord);
      |                                  ^~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferCoord&) const':
buffer.inl.hh:118:23: warning: C++20 says that these are ambiguous, even though the second is reversed:
  118 |     return m_coord == coord;
      |                       ^~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
In file included from buffer_utils.hh:5,
                 from display_buffer.cc:5:
selection.hh: In member function 'bool Kakoune::Selection::operator==(const Kakoune::Selection&) const':
selection.hh:47:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
   47 |         return m_anchor == other.m_anchor and m_cursor == other.m_cursor;
      |                                  ^~~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'Kakoune::BufferCoord& Kakoune::Selection::min()':
selection.hh:54:45: warning: C++20 says that these are ambiguous, even though the second is reversed:
   54 |     BufferCoord& min() { return m_anchor <= m_cursor ? m_anchor : m_cursor; }
      |                                             ^~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'Kakoune::BufferCoord& Kakoune::Selection::max()':
selection.hh:55:45: warning: C++20 says that these are ambiguous, even though the second is reversed:
   55 |     BufferCoord& max() { return m_anchor <= m_cursor ? m_cursor : m_anchor; }
      |                                             ^~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In function 'bool Kakoune::overlaps(const Selection&, const Selection&)':
selection.hh:66:33: warning: C++20 says that these are ambiguous, even though the second is reversed:
   66 |     return lhs.min() <= rhs.min() ? lhs.max() >= rhs.min()
      |                                 ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh:66:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
   66 |     return lhs.min() <= rhs.min() ? lhs.max() >= rhs.min()
      |                                                          ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh:67:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
   67 |                                   : lhs.min() <= rhs.max();
      |                                                          ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer_utils.hh: In function 'bool Kakoune::is_bow(const Buffer&, BufferCoord)':
buffer_utils.hh:54:33: warning: C++20 says that these are ambiguous, even though the second is reversed:
   54 |     if (coord == BufferCoord{0,0})
      |                                 ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer_utils.hh: In function 'bool Kakoune::is_eow(const Buffer&, BufferCoord)':
buffer_utils.hh:62:57: warning: C++20 says that these are ambiguous, even though the second is reversed:
   62 |     if (buffer.is_end(coord) or coord == BufferCoord{0,0})
      |                                                         ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
In file included from memory.hh:8,
                 from string.hh:4,
                 from exception.hh:4,
                 from color.hh:4,
                 from face.hh:4,
                 from display_buffer.hh:4:
display_buffer.cc: In member function 'Kakoune::DisplayLine::iterator Kakoune::DisplayLine::split(iterator, Kakoune::BufferCoord)':
display_buffer.cc:87:30: warning: C++20 says that these are ambiguous, even though the second is reversed:
   87 |     kak_assert(it->begin() < pos);
      |                              ^~~
assert.hh:33:47: note: in definition of macro 'kak_assert'
   33 |     #define kak_assert(...) do { (void)sizeof(__VA_ARGS__); } while(false)
      |                                               ^~~~~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
display_buffer.cc:88:28: warning: C++20 says that these are ambiguous, even though the second is reversed:
   88 |     kak_assert(it->end() > pos);
      |                            ^~~
assert.hh:33:47: note: in definition of macro 'kak_assert'
   33 |     #define kak_assert(...) do { (void)sizeof(__VA_ARGS__); } while(false)
      |                                               ^~~~~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
display_buffer.cc: In member function 'Kakoune::DisplayLine::iterator Kakoune::DisplayLine::split(iterator, Kakoune::ColumnCount)':
display_buffer.cc:111:26: warning: C++20 says that these are ambiguous, even though the second is reversed:
  111 |     if (pos == it->begin()) // Can happen if we try to split in the middle of a multi-column codepoint
      |                          ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
display_buffer.cc:113:24: warning: C++20 says that these are ambiguous, even though the second is reversed:
  113 |     if (pos == it->end())
      |                        ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
display_buffer.cc: In lambda function:
display_buffer.cc:121:54: warning: C++20 says that these are ambiguous, even though the second is reversed:
  121 |         return (a.has_buffer_range() && a.begin() >= pos) ||
      |                                                      ^~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
display_buffer.cc:122:62: warning: C++20 says that these are ambiguous, even though the second is reversed:
  122 |                (a.type() == DisplayAtom::Range and a.end() > pos);
      |                                                              ^~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
display_buffer.cc: In member function 'Kakoune::DisplayLine::iterator Kakoune::DisplayLine::split(Kakoune::BufferCoord)':
display_buffer.cc:124:39: warning: C++20 says that these are ambiguous, even though the second is reversed:
  124 |     if (it == end() or it->begin() >= pos)
      |                                       ^~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
display_buffer.cc: In member function 'void Kakoune::DisplayLine::optimize()':
display_buffer.cc:177:47: warning: C++20 says that these are ambiguous, even though the second is reversed:
  177 |                      next.begin() == atom.end())
      |                                               ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
display_buffer.cc: In member function 'void Kakoune::DisplayLine::compute_range()':
display_buffer.cc:265:41: warning: C++20 says that these are ambiguous, even though the second is reversed:
  265 |     kak_assert(m_range.begin <= m_range.end);
      |                                         ^~~
assert.hh:33:47: note: in definition of macro 'kak_assert'
   33 |     #define kak_assert(...) do { (void)sizeof(__VA_ARGS__); } while(false)
      |                                               ^~~~~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
display_buffer.cc: In member function 'void Kakoune::DisplayBuffer::compute_range()':
display_buffer.cc:278:41: warning: C++20 says that these are ambiguous, even though the second is reversed:
  278 |     kak_assert(m_range.begin <= m_range.end);
      |                                         ^~~
assert.hh:33:47: note: in definition of macro 'kak_assert'
   33 |     #define kak_assert(...) do { (void)sizeof(__VA_ARGS__); } while(false)
      |                                               ^~~~~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
In file included from display_buffer.hh:7:
range.hh: In instantiation of 'bool Kakoune::operator==(const Range<BufferCoord>&, const Range<BufferCoord>&)':
display_buffer.cc:263:20:   required from here
range.hh:15:26: warning: C++20 says that these are ambiguous, even though the second is reversed:
   15 |         return lhs.begin == rhs.begin and lhs.end == rhs.end;
      |                ~~~~~~~~~~^~~~~~~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
range.hh:15:51: warning: C++20 says that these are ambiguous, even though the second is reversed:
   15 |         return lhs.begin == rhs.begin and lhs.end == rhs.end;
      |                                           ~~~~~~~~^~~~~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
make: Entering directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
g++  -O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer  -pedantic -std=c++2a -g -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-address -Wno-init-list-lifetime -MD -MP -MF .event_manager.opt.d -c -o .event_manager.opt.o event_manager.cc
make: Leaving directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
make: Entering directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
g++  -O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer  -pedantic -std=c++2a -g -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-address -Wno-init-list-lifetime -MD -MP -MF .face_registry.opt.d -c -o .face_registry.opt.o face_registry.cc
make: Leaving directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
make: Entering directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
g++  -O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer  -pedantic -std=c++2a -g -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-address -Wno-init-list-lifetime -MD -MP -MF .command_manager.opt.d -c -o .command_manager.opt.o command_manager.cc
make: Leaving directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
In file included from buffer.hh:310,
                 from buffer_utils.hh:4,
                 from command_manager.cc:5:
buffer.inl.hh: In member function 'Kakoune::ByteCount Kakoune::Buffer::distance(Kakoune::BufferCoord, Kakoune::BufferCoord) const':
buffer.inl.hh:32:17: warning: C++20 says that these are ambiguous, even though the second is reversed:
   32 |     if (begin > end)
      |                 ^~~
In file included from command_manager.hh:4,
                 from command_manager.cc:1:
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::Buffer::is_end(Kakoune::BufferCoord) const':
buffer.inl.hh:53:27: warning: C++20 says that these are ambiguous, even though the second is reversed:
   53 |     return c >= end_coord();
      |                           ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferIterator&) const':
buffer.inl.hh:107:66: warning: C++20 says that these are ambiguous, even though the second is reversed:
  107 |     return m_buffer == iterator.m_buffer and m_coord == iterator.m_coord;
      |                                                                  ^~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'std::strong_ordering Kakoune::BufferIterator::operator<=>(const Kakoune::BufferIterator&) const':
buffer.inl.hh:113:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
  113 |     return (m_coord <=> iterator.m_coord);
      |                                  ^~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferCoord&) const':
buffer.inl.hh:118:23: warning: C++20 says that these are ambiguous, even though the second is reversed:
  118 |     return m_coord == coord;
      |                       ^~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
In file included from buffer_utils.hh:5:
selection.hh: In member function 'bool Kakoune::Selection::operator==(const Kakoune::Selection&) const':
selection.hh:47:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
   47 |         return m_anchor == other.m_anchor and m_cursor == other.m_cursor;
      |                                  ^~~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'Kakoune::BufferCoord& Kakoune::Selection::min()':
selection.hh:54:45: warning: C++20 says that these are ambiguous, even though the second is reversed:
   54 |     BufferCoord& min() { return m_anchor <= m_cursor ? m_anchor : m_cursor; }
      |                                             ^~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'Kakoune::BufferCoord& Kakoune::Selection::max()':
selection.hh:55:45: warning: C++20 says that these are ambiguous, even though the second is reversed:
   55 |     BufferCoord& max() { return m_anchor <= m_cursor ? m_cursor : m_anchor; }
      |                                             ^~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In function 'bool Kakoune::overlaps(const Selection&, const Selection&)':
selection.hh:66:33: warning: C++20 says that these are ambiguous, even though the second is reversed:
   66 |     return lhs.min() <= rhs.min() ? lhs.max() >= rhs.min()
      |                                 ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh:66:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
   66 |     return lhs.min() <= rhs.min() ? lhs.max() >= rhs.min()
      |                                                          ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh:67:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
   67 |                                   : lhs.min() <= rhs.max();
      |                                                          ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer_utils.hh: In function 'bool Kakoune::is_bow(const Buffer&, BufferCoord)':
buffer_utils.hh:54:33: warning: C++20 says that these are ambiguous, even though the second is reversed:
   54 |     if (coord == BufferCoord{0,0})
      |                                 ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer_utils.hh: In function 'bool Kakoune::is_eow(const Buffer&, BufferCoord)':
buffer_utils.hh:62:57: warning: C++20 says that these are ambiguous, even though the second is reversed:
   62 |     if (buffer.is_end(coord) or coord == BufferCoord{0,0})
      |                                                         ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
make: Entering directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
g++  -O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer  -pedantic -std=c++2a -g -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-address -Wno-init-list-lifetime -MD -MP -MF .highlighter_group.opt.d -c -o .highlighter_group.opt.o highlighter_group.cc
make: Leaving directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
make: Entering directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
g++  -O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer  -pedantic -std=c++2a -g -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-address -Wno-init-list-lifetime -MD -MP -MF .highlighter.opt.d -c -o .highlighter.opt.o highlighter.cc
make: Leaving directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
In file included from buffer.hh:310,
                 from buffer_utils.hh:4,
                 from highlighter.cc:3:
buffer.inl.hh: In member function 'Kakoune::ByteCount Kakoune::Buffer::distance(Kakoune::BufferCoord, Kakoune::BufferCoord) const':
buffer.inl.hh:32:17: warning: C++20 says that these are ambiguous, even though the second is reversed:
   32 |     if (begin > end)
      |                 ^~~
In file included from highlighter.hh:4,
                 from highlighter.cc:1:
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::Buffer::is_end(Kakoune::BufferCoord) const':
buffer.inl.hh:53:27: warning: C++20 says that these are ambiguous, even though the second is reversed:
   53 |     return c >= end_coord();
      |                           ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferIterator&) const':
buffer.inl.hh:107:66: warning: C++20 says that these are ambiguous, even though the second is reversed:
  107 |     return m_buffer == iterator.m_buffer and m_coord == iterator.m_coord;
      |                                                                  ^~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'std::strong_ordering Kakoune::BufferIterator::operator<=>(const Kakoune::BufferIterator&) const':
buffer.inl.hh:113:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
  113 |     return (m_coord <=> iterator.m_coord);
      |                                  ^~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferCoord&) const':
buffer.inl.hh:118:23: warning: C++20 says that these are ambiguous, even though the second is reversed:
  118 |     return m_coord == coord;
      |                       ^~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
In file included from buffer_utils.hh:5:
selection.hh: In member function 'bool Kakoune::Selection::operator==(const Kakoune::Selection&) const':
selection.hh:47:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
   47 |         return m_anchor == other.m_anchor and m_cursor == other.m_cursor;
      |                                  ^~~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'Kakoune::BufferCoord& Kakoune::Selection::min()':
selection.hh:54:45: warning: C++20 says that these are ambiguous, even though the second is reversed:
   54 |     BufferCoord& min() { return m_anchor <= m_cursor ? m_anchor : m_cursor; }
      |                                             ^~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'Kakoune::BufferCoord& Kakoune::Selection::max()':
selection.hh:55:45: warning: C++20 says that these are ambiguous, even though the second is reversed:
   55 |     BufferCoord& max() { return m_anchor <= m_cursor ? m_cursor : m_anchor; }
      |                                             ^~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In function 'bool Kakoune::overlaps(const Selection&, const Selection&)':
selection.hh:66:33: warning: C++20 says that these are ambiguous, even though the second is reversed:
   66 |     return lhs.min() <= rhs.min() ? lhs.max() >= rhs.min()
      |                                 ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh:66:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
   66 |     return lhs.min() <= rhs.min() ? lhs.max() >= rhs.min()
      |                                                          ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh:67:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
   67 |                                   : lhs.min() <= rhs.max();
      |                                                          ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer_utils.hh: In function 'bool Kakoune::is_bow(const Buffer&, BufferCoord)':
buffer_utils.hh:54:33: warning: C++20 says that these are ambiguous, even though the second is reversed:
   54 |     if (coord == BufferCoord{0,0})
      |                                 ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer_utils.hh: In function 'bool Kakoune::is_eow(const Buffer&, BufferCoord)':
buffer_utils.hh:62:57: warning: C++20 says that these are ambiguous, even though the second is reversed:
   62 |     if (buffer.is_end(coord) or coord == BufferCoord{0,0})
      |                                                         ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
make: Entering directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
g++  -O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer  -pedantic -std=c++2a -g -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-address -Wno-init-list-lifetime -MD -MP -MF .file.opt.d -c -o .file.opt.o file.cc
make: Leaving directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
In file included from buffer.hh:310,
                 from file.cc:4:
buffer.inl.hh: In member function 'Kakoune::ByteCount Kakoune::Buffer::distance(Kakoune::BufferCoord, Kakoune::BufferCoord) const':
buffer.inl.hh:32:17: warning: C++20 says that these are ambiguous, even though the second is reversed:
   32 |     if (begin > end)
      |                 ^~~
In file included from buffer.hh:5:
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::Buffer::is_end(Kakoune::BufferCoord) const':
buffer.inl.hh:53:27: warning: C++20 says that these are ambiguous, even though the second is reversed:
   53 |     return c >= end_coord();
      |                           ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferIterator&) const':
buffer.inl.hh:107:66: warning: C++20 says that these are ambiguous, even though the second is reversed:
  107 |     return m_buffer == iterator.m_buffer and m_coord == iterator.m_coord;
      |                                                                  ^~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'std::strong_ordering Kakoune::BufferIterator::operator<=>(const Kakoune::BufferIterator&) const':
buffer.inl.hh:113:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
  113 |     return (m_coord <=> iterator.m_coord);
      |                                  ^~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferCoord&) const':
buffer.inl.hh:118:23: warning: C++20 says that these are ambiguous, even though the second is reversed:
  118 |     return m_coord == coord;
      |                       ^~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
make: Entering directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
g++  -O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer  -pedantic -std=c++2a -g -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-address -Wno-init-list-lifetime -MD -MP -MF .json.opt.d -c -o .json.opt.o json.cc
make: Leaving directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
json.cc: In lambda function:
json.cc:23:48: warning: comparison is always true due to limited range of data type [-Wtype-limits]
   23 |             return c == '\\' or c == '"' or (c >= 0 and c <= 0x1F);
      |                                              ~~^~~~
json.cc: In function 'Kakoune::String Kakoune::to_json(StringView)':
json.cc:31:19: warning: comparison is always true due to limited range of data type [-Wtype-limits]
   31 |         if (*next >= 0 and *next <= 0x1F)
      |             ~~~~~~^~~~
make: Entering directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
g++  -O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer  -pedantic -std=c++2a -g -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-address -Wno-init-list-lifetime -MD -MP -MF .hash_map.opt.d -c -o .hash_map.opt.o hash_map.cc
make: Leaving directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
In file included from buffer.hh:310,
                 from buffer_utils.hh:4,
                 from hash_map.cc:5:
buffer.inl.hh: In member function 'Kakoune::ByteCount Kakoune::Buffer::distance(Kakoune::BufferCoord, Kakoune::BufferCoord) const':
buffer.inl.hh:32:17: warning: C++20 says that these are ambiguous, even though the second is reversed:
   32 |     if (begin > end)
      |                 ^~~
In file included from buffer.hh:5:
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::Buffer::is_end(Kakoune::BufferCoord) const':
buffer.inl.hh:53:27: warning: C++20 says that these are ambiguous, even though the second is reversed:
   53 |     return c >= end_coord();
      |                           ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferIterator&) const':
buffer.inl.hh:107:66: warning: C++20 says that these are ambiguous, even though the second is reversed:
  107 |     return m_buffer == iterator.m_buffer and m_coord == iterator.m_coord;
      |                                                                  ^~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'std::strong_ordering Kakoune::BufferIterator::operator<=>(const Kakoune::BufferIterator&) const':
buffer.inl.hh:113:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
  113 |     return (m_coord <=> iterator.m_coord);
      |                                  ^~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferCoord&) const':
buffer.inl.hh:118:23: warning: C++20 says that these are ambiguous, even though the second is reversed:
  118 |     return m_coord == coord;
      |                       ^~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
In file included from buffer_utils.hh:5:
selection.hh: In member function 'bool Kakoune::Selection::operator==(const Kakoune::Selection&) const':
selection.hh:47:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
   47 |         return m_anchor == other.m_anchor and m_cursor == other.m_cursor;
      |                                  ^~~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'Kakoune::BufferCoord& Kakoune::Selection::min()':
selection.hh:54:45: warning: C++20 says that these are ambiguous, even though the second is reversed:
   54 |     BufferCoord& min() { return m_anchor <= m_cursor ? m_anchor : m_cursor; }
      |                                             ^~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'Kakoune::BufferCoord& Kakoune::Selection::max()':
selection.hh:55:45: warning: C++20 says that these are ambiguous, even though the second is reversed:
   55 |     BufferCoord& max() { return m_anchor <= m_cursor ? m_cursor : m_anchor; }
      |                                             ^~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In function 'bool Kakoune::overlaps(const Selection&, const Selection&)':
selection.hh:66:33: warning: C++20 says that these are ambiguous, even though the second is reversed:
   66 |     return lhs.min() <= rhs.min() ? lhs.max() >= rhs.min()
      |                                 ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh:66:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
   66 |     return lhs.min() <= rhs.min() ? lhs.max() >= rhs.min()
      |                                                          ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh:67:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
   67 |                                   : lhs.min() <= rhs.max();
      |                                                          ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer_utils.hh: In function 'bool Kakoune::is_bow(const Buffer&, BufferCoord)':
buffer_utils.hh:54:33: warning: C++20 says that these are ambiguous, even though the second is reversed:
   54 |     if (coord == BufferCoord{0,0})
      |                                 ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer_utils.hh: In function 'bool Kakoune::is_eow(const Buffer&, BufferCoord)':
buffer_utils.hh:62:57: warning: C++20 says that these are ambiguous, even though the second is reversed:
   62 |     if (buffer.is_end(coord) or coord == BufferCoord{0,0})
      |                                                         ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
make: Entering directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
g++  -O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer  -pedantic -std=c++2a -g -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-address -Wno-init-list-lifetime -MD -MP -MF .keymap_manager.opt.d -c -o .keymap_manager.opt.o keymap_manager.cc
make: Leaving directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
make: Entering directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
g++  -O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer  -pedantic -std=c++2a -g -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-address -Wno-init-list-lifetime -MD -MP -MF .hook_manager.opt.d -c -o .hook_manager.opt.o hook_manager.cc
make: Leaving directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
In file included from buffer.hh:310,
                 from buffer_utils.hh:4,
                 from hook_manager.cc:3:
buffer.inl.hh: In member function 'Kakoune::ByteCount Kakoune::Buffer::distance(Kakoune::BufferCoord, Kakoune::BufferCoord) const':
buffer.inl.hh:32:17: warning: C++20 says that these are ambiguous, even though the second is reversed:
   32 |     if (begin > end)
      |                 ^~~
In file included from buffer.hh:5:
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::Buffer::is_end(Kakoune::BufferCoord) const':
buffer.inl.hh:53:27: warning: C++20 says that these are ambiguous, even though the second is reversed:
   53 |     return c >= end_coord();
      |                           ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferIterator&) const':
buffer.inl.hh:107:66: warning: C++20 says that these are ambiguous, even though the second is reversed:
  107 |     return m_buffer == iterator.m_buffer and m_coord == iterator.m_coord;
      |                                                                  ^~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'std::strong_ordering Kakoune::BufferIterator::operator<=>(const Kakoune::BufferIterator&) const':
buffer.inl.hh:113:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
  113 |     return (m_coord <=> iterator.m_coord);
      |                                  ^~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferCoord&) const':
buffer.inl.hh:118:23: warning: C++20 says that these are ambiguous, even though the second is reversed:
  118 |     return m_coord == coord;
      |                       ^~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
In file included from buffer_utils.hh:5:
selection.hh: In member function 'bool Kakoune::Selection::operator==(const Kakoune::Selection&) const':
selection.hh:47:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
   47 |         return m_anchor == other.m_anchor and m_cursor == other.m_cursor;
      |                                  ^~~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'Kakoune::BufferCoord& Kakoune::Selection::min()':
selection.hh:54:45: warning: C++20 says that these are ambiguous, even though the second is reversed:
   54 |     BufferCoord& min() { return m_anchor <= m_cursor ? m_anchor : m_cursor; }
      |                                             ^~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'Kakoune::BufferCoord& Kakoune::Selection::max()':
selection.hh:55:45: warning: C++20 says that these are ambiguous, even though the second is reversed:
   55 |     BufferCoord& max() { return m_anchor <= m_cursor ? m_cursor : m_anchor; }
      |                                             ^~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In function 'bool Kakoune::overlaps(const Selection&, const Selection&)':
selection.hh:66:33: warning: C++20 says that these are ambiguous, even though the second is reversed:
   66 |     return lhs.min() <= rhs.min() ? lhs.max() >= rhs.min()
      |                                 ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh:66:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
   66 |     return lhs.min() <= rhs.min() ? lhs.max() >= rhs.min()
      |                                                          ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh:67:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
   67 |                                   : lhs.min() <= rhs.max();
      |                                                          ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer_utils.hh: In function 'bool Kakoune::is_bow(const Buffer&, BufferCoord)':
buffer_utils.hh:54:33: warning: C++20 says that these are ambiguous, even though the second is reversed:
   54 |     if (coord == BufferCoord{0,0})
      |                                 ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer_utils.hh: In function 'bool Kakoune::is_eow(const Buffer&, BufferCoord)':
buffer_utils.hh:62:57: warning: C++20 says that these are ambiguous, even though the second is reversed:
   62 |     if (buffer.is_end(coord) or coord == BufferCoord{0,0})
      |                                                         ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
make: Entering directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
g++  -O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer  -pedantic -std=c++2a -g -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-address -Wno-init-list-lifetime -MD -MP -MF .keys.opt.d -c -o .keys.opt.o keys.cc
make: Leaving directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
make: Entering directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
g++  -O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer  -pedantic -std=c++2a -g -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-address -Wno-init-list-lifetime -MD -MP -MF .memory.opt.d -c -o .memory.opt.o memory.cc
make: Leaving directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
make: Entering directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
g++  -O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer  -pedantic -std=c++2a -g -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-address -Wno-init-list-lifetime -MD -MP -MF .json_ui.opt.d -c -o .json_ui.opt.o json_ui.cc
make: Leaving directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
make: Entering directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
g++  -O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer  -pedantic -std=c++2a -g -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-address -Wno-init-list-lifetime -MD -MP -MF .line_modification.opt.d -c -o .line_modification.opt.o line_modification.cc
make: Leaving directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
In file included from buffer.hh:310,
                 from line_modification.cc:3:
buffer.inl.hh: In member function 'Kakoune::ByteCount Kakoune::Buffer::distance(Kakoune::BufferCoord, Kakoune::BufferCoord) const':
buffer.inl.hh:32:17: warning: C++20 says that these are ambiguous, even though the second is reversed:
   32 |     if (begin > end)
      |                 ^~~
In file included from buffer.hh:5:
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::Buffer::is_end(Kakoune::BufferCoord) const':
buffer.inl.hh:53:27: warning: C++20 says that these are ambiguous, even though the second is reversed:
   53 |     return c >= end_coord();
      |                           ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferIterator&) const':
buffer.inl.hh:107:66: warning: C++20 says that these are ambiguous, even though the second is reversed:
  107 |     return m_buffer == iterator.m_buffer and m_coord == iterator.m_coord;
      |                                                                  ^~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'std::strong_ordering Kakoune::BufferIterator::operator<=>(const Kakoune::BufferIterator&) const':
buffer.inl.hh:113:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
  113 |     return (m_coord <=> iterator.m_coord);
      |                                  ^~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferCoord&) const':
buffer.inl.hh:118:23: warning: C++20 says that these are ambiguous, even though the second is reversed:
  118 |     return m_coord == coord;
      |                       ^~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
make: Entering directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
g++  -O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer  -pedantic -std=c++2a -g -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-address -Wno-init-list-lifetime -MD -MP -MF .input_handler.opt.d -c -o .input_handler.opt.o input_handler.cc
make: Leaving directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
In file included from buffer.hh:310,
                 from selection.hh:4,
                 from context.hh:4,
                 from input_handler.hh:6,
                 from input_handler.cc:1:
buffer.inl.hh: In member function 'Kakoune::ByteCount Kakoune::Buffer::distance(Kakoune::BufferCoord, Kakoune::BufferCoord) const':
buffer.inl.hh:32:17: warning: C++20 says that these are ambiguous, even though the second is reversed:
   32 |     if (begin > end)
      |                 ^~~
In file included from buffer.hh:5:
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::Buffer::is_end(Kakoune::BufferCoord) const':
buffer.inl.hh:53:27: warning: C++20 says that these are ambiguous, even though the second is reversed:
   53 |     return c >= end_coord();
      |                           ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferIterator&) const':
buffer.inl.hh:107:66: warning: C++20 says that these are ambiguous, even though the second is reversed:
  107 |     return m_buffer == iterator.m_buffer and m_coord == iterator.m_coord;
      |                                                                  ^~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'std::strong_ordering Kakoune::BufferIterator::operator<=>(const Kakoune::BufferIterator&) const':
buffer.inl.hh:113:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
  113 |     return (m_coord <=> iterator.m_coord);
      |                                  ^~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferCoord&) const':
buffer.inl.hh:118:23: warning: C++20 says that these are ambiguous, even though the second is reversed:
  118 |     return m_coord == coord;
      |                       ^~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'bool Kakoune::Selection::operator==(const Kakoune::Selection&) const':
selection.hh:47:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
   47 |         return m_anchor == other.m_anchor and m_cursor == other.m_cursor;
      |                                  ^~~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'Kakoune::BufferCoord& Kakoune::Selection::min()':
selection.hh:54:45: warning: C++20 says that these are ambiguous, even though the second is reversed:
   54 |     BufferCoord& min() { return m_anchor <= m_cursor ? m_anchor : m_cursor; }
      |                                             ^~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'Kakoune::BufferCoord& Kakoune::Selection::max()':
selection.hh:55:45: warning: C++20 says that these are ambiguous, even though the second is reversed:
   55 |     BufferCoord& max() { return m_anchor <= m_cursor ? m_cursor : m_anchor; }
      |                                             ^~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In function 'bool Kakoune::overlaps(const Selection&, const Selection&)':
selection.hh:66:33: warning: C++20 says that these are ambiguous, even though the second is reversed:
   66 |     return lhs.min() <= rhs.min() ? lhs.max() >= rhs.min()
      |                                 ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh:66:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
   66 |     return lhs.min() <= rhs.min() ? lhs.max() >= rhs.min()
      |                                                          ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh:67:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
   67 |                                   : lhs.min() <= rhs.max();
      |                                                          ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
In file included from input_handler.cc:4:
buffer_utils.hh: In function 'bool Kakoune::is_bow(const Buffer&, BufferCoord)':
buffer_utils.hh:54:33: warning: C++20 says that these are ambiguous, even though the second is reversed:
   54 |     if (coord == BufferCoord{0,0})
      |                                 ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer_utils.hh: In function 'bool Kakoune::is_eow(const Buffer&, BufferCoord)':
buffer_utils.hh:62:57: warning: C++20 says that these are ambiguous, even though the second is reversed:
   62 |     if (buffer.is_end(coord) or coord == BufferCoord{0,0})
      |                                                         ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
input_handler.cc: In member function 'virtual void Kakoune::InputModes::Insert::on_disabled(bool)':
input_handler.cc:1242:51: warning: C++20 says that these are ambiguous, even though the second is reversed:
 1242 |                     if (sel.cursor() > sel.anchor() and sel.cursor() > BufferCoord{0, 0})
      |                                                   ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
input_handler.cc:1242:88: warning: C++20 says that these are ambiguous, even though the second is reversed:
 1242 |                     if (sel.cursor() > sel.anchor() and sel.cursor() > BufferCoord{0, 0})
      |                                                                                        ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
input_handler.cc: In member function 'virtual void Kakoune::InputModes::Insert::on_key(Kakoune::Key)':
input_handler.cc:1271:52: warning: C++20 says that these are ambiguous, even though the second is reversed:
 1271 |                 if (sel.cursor() == BufferCoord{0,0})
      |                                                    ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
input_handler.cc:1278:50: warning: C++20 says that these are ambiguous, even though the second is reversed:
 1278 |             if (main.cursor() != BufferCoord{0, 0})
      |                                                  ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
input_handler.cc: In member function 'void Kakoune::InputModes::Insert::prepare(Kakoune::InsertMode, int)':
input_handler.cc:1490:54: warning: C++20 says that these are ambiguous, even though the second is reversed:
 1490 |                 if (sel.cursor() == buffer.end_coord())
      |                                                      ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
input_handler.cc: In function 'void Kakoune::scroll_window(Context&, LineCount, bool)':
input_handler.cc:1827:63: warning: C++20 says that these are ambiguous, even though the second is reversed:
 1827 |     BufferCoord new_anchor = (mouse_dragging or new_cursor == cursor) ? anchor : new_cursor;
      |                                                               ^~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
make: Entering directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
g++  -O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer  -pedantic -std=c++2a -g -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-address -Wno-init-list-lifetime -MD -MP -MF .option_manager.opt.d -c -o .option_manager.opt.o option_manager.cc
make: Leaving directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
make: Entering directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
g++  -O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer  -pedantic -std=c++2a -g -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-address -Wno-init-list-lifetime -MD -MP -MF .insert_completer.opt.d -c -o .insert_completer.opt.o insert_completer.cc
make: Leaving directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
In file included from buffer.hh:310,
                 from buffer_manager.hh:4,
                 from insert_completer.cc:3:
buffer.inl.hh: In member function 'Kakoune::ByteCount Kakoune::Buffer::distance(Kakoune::BufferCoord, Kakoune::BufferCoord) const':
buffer.inl.hh:32:17: warning: C++20 says that these are ambiguous, even though the second is reversed:
   32 |     if (begin > end)
      |                 ^~~
In file included from display_buffer.hh:6,
                 from insert_completer.hh:6,
                 from insert_completer.cc:1:
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::Buffer::is_end(Kakoune::BufferCoord) const':
buffer.inl.hh:53:27: warning: C++20 says that these are ambiguous, even though the second is reversed:
   53 |     return c >= end_coord();
      |                           ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferIterator&) const':
buffer.inl.hh:107:66: warning: C++20 says that these are ambiguous, even though the second is reversed:
  107 |     return m_buffer == iterator.m_buffer and m_coord == iterator.m_coord;
      |                                                                  ^~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'std::strong_ordering Kakoune::BufferIterator::operator<=>(const Kakoune::BufferIterator&) const':
buffer.inl.hh:113:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
  113 |     return (m_coord <=> iterator.m_coord);
      |                                  ^~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferCoord&) const':
buffer.inl.hh:118:23: warning: C++20 says that these are ambiguous, even though the second is reversed:
  118 |     return m_coord == coord;
      |                       ^~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
In file included from buffer_utils.hh:5,
                 from insert_completer.cc:4:
selection.hh: In member function 'bool Kakoune::Selection::operator==(const Kakoune::Selection&) const':
selection.hh:47:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
   47 |         return m_anchor == other.m_anchor and m_cursor == other.m_cursor;
      |                                  ^~~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'Kakoune::BufferCoord& Kakoune::Selection::min()':
selection.hh:54:45: warning: C++20 says that these are ambiguous, even though the second is reversed:
   54 |     BufferCoord& min() { return m_anchor <= m_cursor ? m_anchor : m_cursor; }
      |                                             ^~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'Kakoune::BufferCoord& Kakoune::Selection::max()':
selection.hh:55:45: warning: C++20 says that these are ambiguous, even though the second is reversed:
   55 |     BufferCoord& max() { return m_anchor <= m_cursor ? m_cursor : m_anchor; }
      |                                             ^~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In function 'bool Kakoune::overlaps(const Selection&, const Selection&)':
selection.hh:66:33: warning: C++20 says that these are ambiguous, even though the second is reversed:
   66 |     return lhs.min() <= rhs.min() ? lhs.max() >= rhs.min()
      |                                 ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh:66:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
   66 |     return lhs.min() <= rhs.min() ? lhs.max() >= rhs.min()
      |                                                          ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh:67:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
   67 |                                   : lhs.min() <= rhs.max();
      |                                                          ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer_utils.hh: In function 'bool Kakoune::is_bow(const Buffer&, BufferCoord)':
buffer_utils.hh:54:33: warning: C++20 says that these are ambiguous, even though the second is reversed:
   54 |     if (coord == BufferCoord{0,0})
      |                                 ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer_utils.hh: In function 'bool Kakoune::is_eow(const Buffer&, BufferCoord)':
buffer_utils.hh:62:57: warning: C++20 says that these are ambiguous, even though the second is reversed:
   62 |     if (buffer.is_end(coord) or coord == BufferCoord{0,0})
      |                                                         ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
In file included from units.hh:4,
                 from completion.hh:7,
                 from option_manager.hh:4,
                 from insert_completer.hh:4:
insert_completer.cc: In instantiation of 'bool Kakoune::InsertCompleter::try_complete(Func) [with Func = Kakoune::InsertCompletion (*)(const Kakoune::SelectionList&, const Kakoune::OptionManager&, const Kakoune::FaceRegistry&)]':
insert_completer.cc:467:46:   required from here
insert_completer.cc:608:36: warning: C++20 says that these are ambiguous, even though the second is reversed:
  608 |     kak_assert(m_completions.begin <= sels.main().cursor());
assert.hh:33:47: note: in definition of macro 'kak_assert'
   33 |     #define kak_assert(...) do { (void)sizeof(__VA_ARGS__); } while(false)
      |                                               ^~~~~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
insert_completer.cc: In instantiation of 'bool Kakoune::InsertCompleter::try_complete(Func) [with Func = Kakoune::InsertCompleter::setup_ifn()::<lambda(const Kakoune::SelectionList&, const Kakoune::OptionManager&, const Kakoune::FaceRegistry&)>]':
insert_completer.cc:528:29:   required from here
insert_completer.cc:608:36: warning: C++20 says that these are ambiguous, even though the second is reversed:
  608 |     kak_assert(m_completions.begin <= sels.main().cursor());
assert.hh:33:47: note: in definition of macro 'kak_assert'
   33 |     #define kak_assert(...) do { (void)sizeof(__VA_ARGS__); } while(false)
      |                                               ^~~~~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
In file included from insert_completer.cc:7:
changes.hh: In instantiation of 'auto Kakoune::update_range(ForwardChangesTracker&, Range&, AdvanceFunc&&) [with Range = Range<BufferCoord>; AdvanceFunc = update_forward<std::vector<Range<BufferCoord>, Allocator<Range<BufferCoord>, Kakoune::MemoryDomain::Undefined> > >(ConstArrayView<Buffer::Change>, std::vector<Range<BufferCoord>, Allocator<Range<BufferCoord>, Kakoune::MemoryDomain::Undefined> >&)::<lambda(const BufferCoord&)>&]':
changes.hh:59:21:   required from 'void Kakoune::update_forward(ConstArrayView<Buffer::Change>, RangeContainer&) [with RangeContainer = std::vector<Range<BufferCoord>, Allocator<Range<BufferCoord>, Kakoune::MemoryDomain::Undefined> >; ConstArrayView<Buffer::Change> = ArrayView<const Buffer::Change>]'
changes.hh:98:27:   required from 'void Kakoune::update_ranges(Buffer&, size_t&, RangeContainer&&) [with RangeContainer = std::vector<Range<BufferCoord>, Allocator<Range<BufferCoord>, Kakoune::MemoryDomain::Undefined> >&; size_t = long unsigned int]'
insert_completer.cc:497:22:   required from here
changes.hh:39:14: warning: C++20 says that these are ambiguous, even though the second is reversed:
   39 |     if (last < BufferCoord{0,0})
      |         ~~~~~^~~~~~~~~~~~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
changes.hh: In instantiation of 'auto Kakoune::update_range(ForwardChangesTracker&, Range&, AdvanceFunc&&) [with Range = Range<BufferCoord>; AdvanceFunc = update_backward<std::vector<Range<BufferCoord>, Allocator<Range<BufferCoord>, Kakoune::MemoryDomain::Undefined> > >(ConstArrayView<Buffer::Change>, std::vector<Range<BufferCoord>, Allocator<Range<BufferCoord>, Kakoune::MemoryDomain::Undefined> >&)::<lambda(const BufferCoord&)>&]':
changes.hh:81:21:   required from 'void Kakoune::update_backward(ConstArrayView<Buffer::Change>, RangeContainer&) [with RangeContainer = std::vector<Range<BufferCoord>, Allocator<Range<BufferCoord>, Kakoune::MemoryDomain::Undefined> >; ConstArrayView<Buffer::Change> = ArrayView<const Buffer::Change>]'
changes.hh:103:28:   required from 'void Kakoune::update_ranges(Buffer&, size_t&, RangeContainer&&) [with RangeContainer = std::vector<Range<BufferCoord>, Allocator<Range<BufferCoord>, Kakoune::MemoryDomain::Undefined> >&; size_t = long unsigned int]'
insert_completer.cc:497:22:   required from here
changes.hh:39:14: warning: C++20 says that these are ambiguous, even though the second is reversed:
   39 |     if (last < BufferCoord{0,0})
      |         ~~~~~^~~~~~~~~~~~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
changes.hh: In instantiation of 'Kakoune::update_forward<std::vector<Range<BufferCoord>, Allocator<Range<BufferCoord>, Kakoune::MemoryDomain::Undefined> > >(ConstArrayView<Buffer::Change>, std::vector<Range<BufferCoord>, Allocator<Range<BufferCoord>, Kakoune::MemoryDomain::Undefined> >&)::<lambda(auto:69&, const Kakoune::Buffer::Change&)> [with auto:69 = Kakoune::Range<Kakoune::BufferCoord>]':
/usr/include/c++/13/bits/predefined_ops.h:196:23:   required from 'constexpr bool __gnu_cxx::__ops::_Iter_comp_val<_Compare>::operator()(_Iterator, _Value&) [with _Iterator = __gnu_cxx::__normal_iterator<Kakoune::Range<Kakoune::BufferCoord>*, std::vector<Kakoune::Range<Kakoune::BufferCoord>, Kakoune::Allocator<Kakoune::Range<Kakoune::BufferCoord>, Kakoune::MemoryDomain::Undefined> > >; _Value = const Kakoune::Buffer::Change; _Compare = Kakoune::update_forward<std::vector<Range<BufferCoord>, Allocator<Range<BufferCoord>, Kakoune::MemoryDomain::Undefined> > >(ConstArrayView<Buffer::Change>, std::vector<Range<BufferCoord>, Allocator<Range<BufferCoord>, Kakoune::MemoryDomain::Undefined> >&)::<lambda(auto:69&, const Kakoune::Buffer::Change&)>]'
/usr/include/c++/13/bits/stl_algobase.h:1472:14:   required from 'constexpr _ForwardIterator std::__lower_bound(_ForwardIterator, _ForwardIterator, const _Tp&, _Compare) [with _ForwardIterator = __gnu_cxx::__normal_iterator<Kakoune::Range<Kakoune::BufferCoord>*, vector<Kakoune::Range<Kakoune::BufferCoord>, Kakoune::Allocator<Kakoune::Range<Kakoune::BufferCoord>, Kakoune::MemoryDomain::Undefined> > >; _Tp = Kakoune::Buffer::Change; _Compare = __gnu_cxx::__ops::_Iter_comp_val<Kakoune::update_forward<std::vector<Range<BufferCoord>, Allocator<Range<BufferCoord>, Kakoune::MemoryDomain::Undefined> > >(ConstArrayView<Buffer::Change>, std::vector<Range<BufferCoord>, Allocator<Range<BufferCoord>, Kakoune::MemoryDomain::Undefined> >&)::<lambda(auto:69&, const Kakoune::Buffer::Change&)> >]'
/usr/include/c++/13/bits/stl_algo.h:2015:32:   required from 'constexpr _FIter std::lower_bound(_FIter, _FIter, const _Tp&, _Compare) [with _FIter = __gnu_cxx::__normal_iterator<Kakoune::Range<Kakoune::BufferCoord>*, vector<Kakoune::Range<Kakoune::BufferCoord>, Kakoune::Allocator<Kakoune::Range<Kakoune::BufferCoord>, Kakoune::MemoryDomain::Undefined> > >; _Tp = Kakoune::Buffer::Change; _Compare = Kakoune::update_forward<std::vector<Range<BufferCoord>, Allocator<Range<BufferCoord>, Kakoune::MemoryDomain::Undefined> > >(ConstArrayView<Buffer::Change>, std::vector<Range<BufferCoord>, Allocator<Range<BufferCoord>, Kakoune::MemoryDomain::Undefined> >&)::<lambda(auto:69&, const Kakoune::Buffer::Change&)>]'
changes.hh:56:37:   required from 'void Kakoune::update_forward(ConstArrayView<Buffer::Change>, RangeContainer&) [with RangeContainer = std::vector<Range<BufferCoord>, Allocator<Range<BufferCoord>, Kakoune::MemoryDomain::Undefined> >; ConstArrayView<Buffer::Change> = ArrayView<const Buffer::Change>]'
changes.hh:98:27:   required from 'void Kakoune::update_ranges(Buffer&, size_t&, RangeContainer&&) [with RangeContainer = std::vector<Range<BufferCoord>, Allocator<Range<BufferCoord>, Kakoune::MemoryDomain::Undefined> >&; size_t = long unsigned int]'
insert_completer.cc:497:22:   required from here
changes.hh:57:109: warning: C++20 says that these are ambiguous, even though the second is reversed:
   57 |                                      [](auto& range, const Buffer::Change& change) { return get_last(range) < change.begin; });
      |                                                                                             ~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
In file included from display_buffer.hh:7:
range.hh: In instantiation of 'bool Kakoune::Range<T>::empty() const [with T = Kakoune::BufferCoord]':
insert_completer.cc:498:87:   required from 'Kakoune::InsertCompleter::reset()::<lambda(auto:81&&)> [with auto:81 = Kakoune::Range<Kakoune::BufferCoord>&]'
ranges.hh:158:53:   required from 'void Kakoune::FilterView<Range, Filter>::Iterator::do_filter() [with Range = std::vector<Kakoune::Range<Kakoune::BufferCoord>, Kakoune::Allocator<Kakoune::Range<Kakoune::BufferCoord>, Kakoune::MemoryDomain::Undefined> >&; Filter = Kakoune::InsertCompleter::reset()::<lambda(auto:81&&)>]'
ranges.hh:140:42:   required from 'Kakoune::FilterView<Range, Filter>::Iterator& Kakoune::FilterView<Range, Filter>::Iterator::operator++() [with Range = std::vector<Kakoune::Range<Kakoune::BufferCoord>, Kakoune::Allocator<Kakoune::Range<Kakoune::BufferCoord>, Kakoune::MemoryDomain::Undefined> >&; Filter = Kakoune::InsertCompleter::reset()::<lambda(auto:81&&)>]'
ranges.hh:254:34:   required from 'Kakoune::TransformView<Range, Transform>::Iterator& Kakoune::TransformView<Range, Transform>::Iterator::operator++() [with Range = Kakoune::FilterView<std::vector<Kakoune::Range<Kakoune::BufferCoord>, Kakoune::Allocator<Kakoune::Range<Kakoune::BufferCoord>, Kakoune::MemoryDomain::Undefined> >&, Kakoune::InsertCompleter::reset()::<lambda(auto:81&&)> >; Transform = Kakoune::InsertCompleter::reset()::<lambda(auto:82&&)>]'
string_utils.hh:38:5:   required from 'Kakoune::String Kakoune::join(const Container&, char, bool) [with Container = TransformView<FilterView<std::vector<Range<BufferCoord>, Allocator<Range<BufferCoord>, Kakoune::MemoryDomain::Undefined> >&, InsertCompleter::reset()::<lambda(auto:81&&)> >, InsertCompleter::reset()::<lambda(auto:82&&)> >]'
insert_completer.cc:498:26:   required from here
range.hh:28:39: warning: C++20 says that these are ambiguous, even though the second is reversed:
   28 |     bool empty() const { return begin == end; }
      |                                 ~~~~~~^~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
insert_completer.cc: In instantiation of 'Kakoune::{anonymous}::complete_option(const Kakoune::SelectionList&, const Kakoune::OptionManager&, const Kakoune::FaceRegistry&, Kakoune::StringView)::<lambda(auto:78&&)> [with auto:78 = const Kakoune::Buffer::Change&]':
/usr/include/c++/13/bits/predefined_ops.h:318:23:   required from 'constexpr bool __gnu_cxx::__ops::_Iter_pred<_Predicate>::operator()(_Iterator) [with _Iterator = const Kakoune::Buffer::Change*; _Predicate = Kakoune::{anonymous}::complete_option(const Kakoune::SelectionList&, const Kakoune::OptionManager&, const Kakoune::FaceRegistry&, Kakoune::StringView)::<lambda(auto:78&&)>]'
/usr/include/c++/13/bits/stl_algobase.h:2072:14:   required from 'constexpr _RandomAccessIterator std::__find_if(_RandomAccessIterator, _RandomAccessIterator, _Predicate, random_access_iterator_tag) [with _RandomAccessIterator = const Kakoune::Buffer::Change*; _Predicate = __gnu_cxx::__ops::_Iter_pred<Kakoune::{anonymous}::complete_option(const Kakoune::SelectionList&, const Kakoune::OptionManager&, const Kakoune::FaceRegistry&, Kakoune::StringView)::<lambda(auto:78&&)> >]'
/usr/include/c++/13/bits/stl_algobase.h:2117:23:   required from 'constexpr _Iterator std::__find_if(_Iterator, _Iterator, _Predicate) [with _Iterator = const Kakoune::Buffer::Change*; _Predicate = __gnu_cxx::__ops::_Iter_pred<Kakoune::{anonymous}::complete_option(const Kakoune::SelectionList&, const Kakoune::OptionManager&, const Kakoune::FaceRegistry&, Kakoune::StringView)::<lambda(auto:78&&)> >]'
/usr/include/c++/13/bits/stl_algo.h:3923:28:   required from 'constexpr _IIter std::find_if(_IIter, _IIter, _Predicate) [with _IIter = const Kakoune::Buffer::Change*; _Predicate = Kakoune::{anonymous}::complete_option(const Kakoune::SelectionList&, const Kakoune::OptionManager&, const Kakoune::FaceRegistry&, Kakoune::StringView)::<lambda(auto:78&&)>]'
/usr/include/c++/13/bits/stl_algo.h:477:47:   required from 'constexpr bool std::none_of(_IIter, _IIter, _Predicate) [with _IIter = const Kakoune::Buffer::Change*; _Predicate = Kakoune::{anonymous}::complete_option(const Kakoune::SelectionList&, const Kakoune::OptionManager&, const Kakoune::FaceRegistry&, Kakoune::StringView)::<lambda(auto:78&&)>]'
/usr/include/c++/13/bits/stl_algo.h:496:27:   required from 'constexpr bool std::any_of(_IIter, _IIter, _Predicate) [with _IIter = const Kakoune::Buffer::Change*; _Predicate = Kakoune::{anonymous}::complete_option(const Kakoune::SelectionList&, const Kakoune::OptionManager&, const Kakoune::FaceRegistry&, Kakoune::StringView)::<lambda(auto:78&&)>]'
ranges.hh:589:23:   required from 'bool Kakoune::any_of(Range&&, T) [with Range = ArrayView<const Buffer::Change>&; T = {anonymous}::complete_option(const Kakoune::SelectionList&, const Kakoune::OptionManager&, const Kakoune::FaceRegistry&, Kakoune::StringView)::<lambda(auto:78&&)>]'
insert_completer.cc:279:15:   required from here
insert_completer.cc:279:66: warning: C++20 says that these are ambiguous, even though the second is reversed:
  279 |     if (any_of(changes, [&](auto&& change) { return change.begin < coord; }))
      |                                                     ~~~~~~~~~~~~~^~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
make: Entering directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
g++  -O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer  -pedantic -std=c++2a -g -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-address -Wno-init-list-lifetime -MD -MP -MF .ranked_match.opt.d -c -o .ranked_match.opt.o ranked_match.cc
make: Leaving directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
make: Entering directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
g++  -O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer  -pedantic -std=c++2a -g -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-address -Wno-init-list-lifetime -MD -MP -MF .ranges.opt.d -c -o .ranges.opt.o ranges.cc
make: Leaving directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
make: Entering directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
g++  -O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer  -pedantic -std=c++2a -g -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-address -Wno-init-list-lifetime -MD -MP -MF .parameters_parser.opt.d -c -o .parameters_parser.opt.o parameters_parser.cc
make: Leaving directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
make: Entering directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
g++  -O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer  -pedantic -std=c++2a -g -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-address -Wno-init-list-lifetime -MD -MP -MF .option_types.opt.d -c -o .option_types.opt.o option_types.cc
make: Leaving directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
make: Entering directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
g++  -O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer  -pedantic -std=c++2a -g -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-address -Wno-init-list-lifetime -MD -MP -MF .regex.opt.d -c -o .regex.opt.o regex.cc
make: Leaving directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
make: Entering directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
g++  -O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer  -pedantic -std=c++2a -g -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-address -Wno-init-list-lifetime -MD -MP -MF .regex_impl.opt.d -c -o .regex_impl.opt.o regex_impl.cc
regex_impl.cc:83:20: warning: ignoring packed attribute because of unpacked non-POD field 'Kakoune::ParsedRegex::Quantifier Kakoune::ParsedRegex::Node::quantifier'
   83 |         Quantifier quantifier;
      |                    ^~~~~~~~~~
make: Leaving directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
make: Entering directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
g++  -O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer  -pedantic -std=c++2a -g -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-address -Wno-init-list-lifetime -MD -MP -MF .scope.opt.d -c -o .scope.opt.o scope.cc
make: Leaving directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
In file included from buffer.hh:310,
                 from selection.hh:4,
                 from context.hh:4,
                 from scope.cc:2:
buffer.inl.hh: In member function 'Kakoune::ByteCount Kakoune::Buffer::distance(Kakoune::BufferCoord, Kakoune::BufferCoord) const':
buffer.inl.hh:32:17: warning: C++20 says that these are ambiguous, even though the second is reversed:
   32 |     if (begin > end)
      |                 ^~~
In file included from highlighter.hh:4,
                 from highlighter_group.hh:6,
                 from scope.hh:6,
                 from scope.cc:1:
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::Buffer::is_end(Kakoune::BufferCoord) const':
buffer.inl.hh:53:27: warning: C++20 says that these are ambiguous, even though the second is reversed:
   53 |     return c >= end_coord();
      |                           ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferIterator&) const':
buffer.inl.hh:107:66: warning: C++20 says that these are ambiguous, even though the second is reversed:
  107 |     return m_buffer == iterator.m_buffer and m_coord == iterator.m_coord;
      |                                                                  ^~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'std::strong_ordering Kakoune::BufferIterator::operator<=>(const Kakoune::BufferIterator&) const':
buffer.inl.hh:113:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
  113 |     return (m_coord <=> iterator.m_coord);
      |                                  ^~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferCoord&) const':
buffer.inl.hh:118:23: warning: C++20 says that these are ambiguous, even though the second is reversed:
  118 |     return m_coord == coord;
      |                       ^~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'bool Kakoune::Selection::operator==(const Kakoune::Selection&) const':
selection.hh:47:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
   47 |         return m_anchor == other.m_anchor and m_cursor == other.m_cursor;
      |                                  ^~~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'Kakoune::BufferCoord& Kakoune::Selection::min()':
selection.hh:54:45: warning: C++20 says that these are ambiguous, even though the second is reversed:
   54 |     BufferCoord& min() { return m_anchor <= m_cursor ? m_anchor : m_cursor; }
      |                                             ^~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'Kakoune::BufferCoord& Kakoune::Selection::max()':
selection.hh:55:45: warning: C++20 says that these are ambiguous, even though the second is reversed:
   55 |     BufferCoord& max() { return m_anchor <= m_cursor ? m_cursor : m_anchor; }
      |                                             ^~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In function 'bool Kakoune::overlaps(const Selection&, const Selection&)':
selection.hh:66:33: warning: C++20 says that these are ambiguous, even though the second is reversed:
   66 |     return lhs.min() <= rhs.min() ? lhs.max() >= rhs.min()
      |                                 ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh:66:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
   66 |     return lhs.min() <= rhs.min() ? lhs.max() >= rhs.min()
      |                                                          ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh:67:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
   67 |                                   : lhs.min() <= rhs.max();
      |                                                          ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
make: Entering directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
g++  -O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer  -pedantic -std=c++2a -g -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-address -Wno-init-list-lifetime -MD -MP -MF .register_manager.opt.d -c -o .register_manager.opt.o register_manager.cc
make: Leaving directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
In file included from buffer.hh:310,
                 from selection.hh:4,
                 from context.hh:4,
                 from register_manager.cc:4:
buffer.inl.hh: In member function 'Kakoune::ByteCount Kakoune::Buffer::distance(Kakoune::BufferCoord, Kakoune::BufferCoord) const':
buffer.inl.hh:32:17: warning: C++20 says that these are ambiguous, even though the second is reversed:
   32 |     if (begin > end)
      |                 ^~~
In file included from buffer.hh:5:
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::Buffer::is_end(Kakoune::BufferCoord) const':
buffer.inl.hh:53:27: warning: C++20 says that these are ambiguous, even though the second is reversed:
   53 |     return c >= end_coord();
      |                           ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferIterator&) const':
buffer.inl.hh:107:66: warning: C++20 says that these are ambiguous, even though the second is reversed:
  107 |     return m_buffer == iterator.m_buffer and m_coord == iterator.m_coord;
      |                                                                  ^~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'std::strong_ordering Kakoune::BufferIterator::operator<=>(const Kakoune::BufferIterator&) const':
buffer.inl.hh:113:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
  113 |     return (m_coord <=> iterator.m_coord);
      |                                  ^~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferCoord&) const':
buffer.inl.hh:118:23: warning: C++20 says that these are ambiguous, even though the second is reversed:
  118 |     return m_coord == coord;
      |                       ^~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'bool Kakoune::Selection::operator==(const Kakoune::Selection&) const':
selection.hh:47:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
   47 |         return m_anchor == other.m_anchor and m_cursor == other.m_cursor;
      |                                  ^~~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'Kakoune::BufferCoord& Kakoune::Selection::min()':
selection.hh:54:45: warning: C++20 says that these are ambiguous, even though the second is reversed:
   54 |     BufferCoord& min() { return m_anchor <= m_cursor ? m_anchor : m_cursor; }
      |                                             ^~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'Kakoune::BufferCoord& Kakoune::Selection::max()':
selection.hh:55:45: warning: C++20 says that these are ambiguous, even though the second is reversed:
   55 |     BufferCoord& max() { return m_anchor <= m_cursor ? m_cursor : m_anchor; }
      |                                             ^~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In function 'bool Kakoune::overlaps(const Selection&, const Selection&)':
selection.hh:66:33: warning: C++20 says that these are ambiguous, even though the second is reversed:
   66 |     return lhs.min() <= rhs.min() ? lhs.max() >= rhs.min()
      |                                 ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh:66:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
   66 |     return lhs.min() <= rhs.min() ? lhs.max() >= rhs.min()
      |                                                          ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh:67:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
   67 |                                   : lhs.min() <= rhs.max();
      |                                                          ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
make: Entering directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
g++  -O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer  -pedantic -std=c++2a -g -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-address -Wno-init-list-lifetime -MD -MP -MF .commands.opt.d -c -o .commands.opt.o commands.cc
make: Leaving directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
In file included from buffer.hh:310,
                 from commands.cc:3:
buffer.inl.hh: In member function 'Kakoune::ByteCount Kakoune::Buffer::distance(Kakoune::BufferCoord, Kakoune::BufferCoord) const':
buffer.inl.hh:32:17: warning: C++20 says that these are ambiguous, even though the second is reversed:
   32 |     if (begin > end)
      |                 ^~~
In file included from buffer.hh:5:
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::Buffer::is_end(Kakoune::BufferCoord) const':
buffer.inl.hh:53:27: warning: C++20 says that these are ambiguous, even though the second is reversed:
   53 |     return c >= end_coord();
      |                           ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferIterator&) const':
buffer.inl.hh:107:66: warning: C++20 says that these are ambiguous, even though the second is reversed:
  107 |     return m_buffer == iterator.m_buffer and m_coord == iterator.m_coord;
      |                                                                  ^~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'std::strong_ordering Kakoune::BufferIterator::operator<=>(const Kakoune::BufferIterator&) const':
buffer.inl.hh:113:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
  113 |     return (m_coord <=> iterator.m_coord);
      |                                  ^~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferCoord&) const':
buffer.inl.hh:118:23: warning: C++20 says that these are ambiguous, even though the second is reversed:
  118 |     return m_coord == coord;
      |                       ^~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
In file included from buffer_utils.hh:5,
                 from commands.cc:5:
selection.hh: In member function 'bool Kakoune::Selection::operator==(const Kakoune::Selection&) const':
selection.hh:47:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
   47 |         return m_anchor == other.m_anchor and m_cursor == other.m_cursor;
      |                                  ^~~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'Kakoune::BufferCoord& Kakoune::Selection::min()':
selection.hh:54:45: warning: C++20 says that these are ambiguous, even though the second is reversed:
   54 |     BufferCoord& min() { return m_anchor <= m_cursor ? m_anchor : m_cursor; }
      |                                             ^~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'Kakoune::BufferCoord& Kakoune::Selection::max()':
selection.hh:55:45: warning: C++20 says that these are ambiguous, even though the second is reversed:
   55 |     BufferCoord& max() { return m_anchor <= m_cursor ? m_cursor : m_anchor; }
      |                                             ^~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In function 'bool Kakoune::overlaps(const Selection&, const Selection&)':
selection.hh:66:33: warning: C++20 says that these are ambiguous, even though the second is reversed:
   66 |     return lhs.min() <= rhs.min() ? lhs.max() >= rhs.min()
      |                                 ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh:66:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
   66 |     return lhs.min() <= rhs.min() ? lhs.max() >= rhs.min()
      |                                                          ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh:67:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
   67 |                                   : lhs.min() <= rhs.max();
      |                                                          ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer_utils.hh: In function 'bool Kakoune::is_bow(const Buffer&, BufferCoord)':
buffer_utils.hh:54:33: warning: C++20 says that these are ambiguous, even though the second is reversed:
   54 |     if (coord == BufferCoord{0,0})
      |                                 ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer_utils.hh: In function 'bool Kakoune::is_eow(const Buffer&, BufferCoord)':
buffer_utils.hh:62:57: warning: C++20 says that these are ambiguous, even though the second is reversed:
   62 |     if (buffer.is_end(coord) or coord == BufferCoord{0,0})
      |                                                         ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
In file included from commands.cc:16:
highlighters.hh: In function 'bool Kakoune::operator==(const InclusiveBufferRange&, const InclusiveBufferRange&)':
highlighters.hh:17:29: warning: C++20 says that these are ambiguous, even though the second is reversed:
   17 |     return lhs.first == rhs.first and lhs.last == rhs.last;
      |                             ^~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.hh:17:55: warning: C++20 says that these are ambiguous, even though the second is reversed:
   17 |     return lhs.first == rhs.first and lhs.last == rhs.last;
      |                                                       ^~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
commands.cc: In lambda function:
commands.cc:2609:50: warning: redundant move in initialization [-Wredundant-move]
 2609 |         context.keymaps().add_user_mode(std::move(parser[0]));
      |                                         ~~~~~~~~~^~~~~~~~~~~
commands.cc:2609:50: note: remove 'std::move' call
commands.cc: In lambda function:
commands.cc:2665:43: warning: redundant move in initialization [-Wredundant-move]
 2665 |         enter_user_mode(context, std::move(parser[0]), mode, lock);
      |                                  ~~~~~~~~~^~~~~~~~~~~
commands.cc:2665:43: note: remove 'std::move' call
commands.cc: In instantiation of 'void Kakoune::{anonymous}::edit(const Kakoune::ParametersParser&, Kakoune::Context&, const Kakoune::ShellContext&) [with bool force_reload = false]':
commands.cc:461:5:   required from here
commands.cc:389:47: warning: redundant move in initialization [-Wredundant-move]
  389 |             buffer = create_buffer_from_string(std::move(name), flags, {});
      |                      ~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~
commands.cc:389:47: note: remove 'std::move' call
commands.cc: In instantiation of 'void Kakoune::{anonymous}::edit(const Kakoune::ParametersParser&, Kakoune::Context&, const Kakoune::ShellContext&) [with bool force_reload = true]':
commands.cc:473:5:   required from here
commands.cc:389:47: warning: redundant move in initialization [-Wredundant-move]
commands.cc:389:47: note: remove 'std::move' call
make: Entering directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
g++  -O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer  -pedantic -std=c++2a -g -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-address -Wno-init-list-lifetime -MD -MP -MF .remote.opt.d -c -o .remote.opt.o remote.cc
make: Leaving directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
In file included from buffer.hh:310,
                 from buffer_manager.hh:4,
                 from remote.cc:3:
buffer.inl.hh: In member function 'Kakoune::ByteCount Kakoune::Buffer::distance(Kakoune::BufferCoord, Kakoune::BufferCoord) const':
buffer.inl.hh:32:17: warning: C++20 says that these are ambiguous, even though the second is reversed:
   32 |     if (begin > end)
      |                 ^~~
In file included from buffer.hh:5:
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::Buffer::is_end(Kakoune::BufferCoord) const':
buffer.inl.hh:53:27: warning: C++20 says that these are ambiguous, even though the second is reversed:
   53 |     return c >= end_coord();
      |                           ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferIterator&) const':
buffer.inl.hh:107:66: warning: C++20 says that these are ambiguous, even though the second is reversed:
  107 |     return m_buffer == iterator.m_buffer and m_coord == iterator.m_coord;
      |                                                                  ^~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'std::strong_ordering Kakoune::BufferIterator::operator<=>(const Kakoune::BufferIterator&) const':
buffer.inl.hh:113:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
  113 |     return (m_coord <=> iterator.m_coord);
      |                                  ^~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferCoord&) const':
buffer.inl.hh:118:23: warning: C++20 says that these are ambiguous, even though the second is reversed:
  118 |     return m_coord == coord;
      |                       ^~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
In file included from buffer_utils.hh:5,
                 from remote.cc:4:
selection.hh: In member function 'bool Kakoune::Selection::operator==(const Kakoune::Selection&) const':
selection.hh:47:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
   47 |         return m_anchor == other.m_anchor and m_cursor == other.m_cursor;
      |                                  ^~~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'Kakoune::BufferCoord& Kakoune::Selection::min()':
selection.hh:54:45: warning: C++20 says that these are ambiguous, even though the second is reversed:
   54 |     BufferCoord& min() { return m_anchor <= m_cursor ? m_anchor : m_cursor; }
      |                                             ^~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'Kakoune::BufferCoord& Kakoune::Selection::max()':
selection.hh:55:45: warning: C++20 says that these are ambiguous, even though the second is reversed:
   55 |     BufferCoord& max() { return m_anchor <= m_cursor ? m_cursor : m_anchor; }
      |                                             ^~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In function 'bool Kakoune::overlaps(const Selection&, const Selection&)':
selection.hh:66:33: warning: C++20 says that these are ambiguous, even though the second is reversed:
   66 |     return lhs.min() <= rhs.min() ? lhs.max() >= rhs.min()
      |                                 ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh:66:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
   66 |     return lhs.min() <= rhs.min() ? lhs.max() >= rhs.min()
      |                                                          ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh:67:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
   67 |                                   : lhs.min() <= rhs.max();
      |                                                          ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer_utils.hh: In function 'bool Kakoune::is_bow(const Buffer&, BufferCoord)':
buffer_utils.hh:54:33: warning: C++20 says that these are ambiguous, even though the second is reversed:
   54 |     if (coord == BufferCoord{0,0})
      |                                 ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer_utils.hh: In function 'bool Kakoune::is_eow(const Buffer&, BufferCoord)':
buffer_utils.hh:62:57: warning: C++20 says that these are ambiguous, even though the second is reversed:
   62 |     if (buffer.is_end(coord) or coord == BufferCoord{0,0})
      |                                                         ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
make: Entering directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
g++  -O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer  -pedantic -std=c++2a -g -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-address -Wno-init-list-lifetime -MD -MP -MF .shared_string.opt.d -c -o .shared_string.opt.o shared_string.cc
make: Leaving directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
In file included from buffer.hh:310,
                 from buffer_utils.hh:4,
                 from shared_string.cc:2:
buffer.inl.hh: In member function 'Kakoune::ByteCount Kakoune::Buffer::distance(Kakoune::BufferCoord, Kakoune::BufferCoord) const':
buffer.inl.hh:32:17: warning: C++20 says that these are ambiguous, even though the second is reversed:
   32 |     if (begin > end)
      |                 ^~~
In file included from buffer.hh:5:
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::Buffer::is_end(Kakoune::BufferCoord) const':
buffer.inl.hh:53:27: warning: C++20 says that these are ambiguous, even though the second is reversed:
   53 |     return c >= end_coord();
      |                           ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferIterator&) const':
buffer.inl.hh:107:66: warning: C++20 says that these are ambiguous, even though the second is reversed:
  107 |     return m_buffer == iterator.m_buffer and m_coord == iterator.m_coord;
      |                                                                  ^~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'std::strong_ordering Kakoune::BufferIterator::operator<=>(const Kakoune::BufferIterator&) const':
buffer.inl.hh:113:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
  113 |     return (m_coord <=> iterator.m_coord);
      |                                  ^~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferCoord&) const':
buffer.inl.hh:118:23: warning: C++20 says that these are ambiguous, even though the second is reversed:
  118 |     return m_coord == coord;
      |                       ^~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
In file included from buffer_utils.hh:5:
selection.hh: In member function 'bool Kakoune::Selection::operator==(const Kakoune::Selection&) const':
selection.hh:47:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
   47 |         return m_anchor == other.m_anchor and m_cursor == other.m_cursor;
      |                                  ^~~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'Kakoune::BufferCoord& Kakoune::Selection::min()':
selection.hh:54:45: warning: C++20 says that these are ambiguous, even though the second is reversed:
   54 |     BufferCoord& min() { return m_anchor <= m_cursor ? m_anchor : m_cursor; }
      |                                             ^~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'Kakoune::BufferCoord& Kakoune::Selection::max()':
selection.hh:55:45: warning: C++20 says that these are ambiguous, even though the second is reversed:
   55 |     BufferCoord& max() { return m_anchor <= m_cursor ? m_cursor : m_anchor; }
      |                                             ^~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In function 'bool Kakoune::overlaps(const Selection&, const Selection&)':
selection.hh:66:33: warning: C++20 says that these are ambiguous, even though the second is reversed:
   66 |     return lhs.min() <= rhs.min() ? lhs.max() >= rhs.min()
      |                                 ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh:66:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
   66 |     return lhs.min() <= rhs.min() ? lhs.max() >= rhs.min()
      |                                                          ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh:67:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
   67 |                                   : lhs.min() <= rhs.max();
      |                                                          ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer_utils.hh: In function 'bool Kakoune::is_bow(const Buffer&, BufferCoord)':
buffer_utils.hh:54:33: warning: C++20 says that these are ambiguous, even though the second is reversed:
   54 |     if (coord == BufferCoord{0,0})
      |                                 ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer_utils.hh: In function 'bool Kakoune::is_eow(const Buffer&, BufferCoord)':
buffer_utils.hh:62:57: warning: C++20 says that these are ambiguous, even though the second is reversed:
   62 |     if (buffer.is_end(coord) or coord == BufferCoord{0,0})
      |                                                         ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
make: Entering directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
g++  -O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer  -pedantic -std=c++2a -g -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-address -Wno-init-list-lifetime -MD -MP -MF .string.opt.d -c -o .string.opt.o string.cc
make: Leaving directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
make: Entering directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
g++  -O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer  -pedantic -std=c++2a -g -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-address -Wno-init-list-lifetime -MD -MP -MF .selection.opt.d -c -o .selection.opt.o selection.cc
make: Leaving directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
In file included from buffer.hh:310,
                 from selection.hh:4,
                 from selection.cc:1:
buffer.inl.hh: In member function 'Kakoune::ByteCount Kakoune::Buffer::distance(Kakoune::BufferCoord, Kakoune::BufferCoord) const':
buffer.inl.hh:32:17: warning: C++20 says that these are ambiguous, even though the second is reversed:
   32 |     if (begin > end)
      |                 ^~~
In file included from buffer.hh:5:
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::Buffer::is_end(Kakoune::BufferCoord) const':
buffer.inl.hh:53:27: warning: C++20 says that these are ambiguous, even though the second is reversed:
   53 |     return c >= end_coord();
      |                           ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferIterator&) const':
buffer.inl.hh:107:66: warning: C++20 says that these are ambiguous, even though the second is reversed:
  107 |     return m_buffer == iterator.m_buffer and m_coord == iterator.m_coord;
      |                                                                  ^~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'std::strong_ordering Kakoune::BufferIterator::operator<=>(const Kakoune::BufferIterator&) const':
buffer.inl.hh:113:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
  113 |     return (m_coord <=> iterator.m_coord);
      |                                  ^~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferCoord&) const':
buffer.inl.hh:118:23: warning: C++20 says that these are ambiguous, even though the second is reversed:
  118 |     return m_coord == coord;
      |                       ^~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'bool Kakoune::Selection::operator==(const Kakoune::Selection&) const':
selection.hh:47:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
   47 |         return m_anchor == other.m_anchor and m_cursor == other.m_cursor;
      |                                  ^~~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'Kakoune::BufferCoord& Kakoune::Selection::min()':
selection.hh:54:45: warning: C++20 says that these are ambiguous, even though the second is reversed:
   54 |     BufferCoord& min() { return m_anchor <= m_cursor ? m_anchor : m_cursor; }
      |                                             ^~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'Kakoune::BufferCoord& Kakoune::Selection::max()':
selection.hh:55:45: warning: C++20 says that these are ambiguous, even though the second is reversed:
   55 |     BufferCoord& max() { return m_anchor <= m_cursor ? m_cursor : m_anchor; }
      |                                             ^~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In function 'bool Kakoune::overlaps(const Selection&, const Selection&)':
selection.hh:66:33: warning: C++20 says that these are ambiguous, even though the second is reversed:
   66 |     return lhs.min() <= rhs.min() ? lhs.max() >= rhs.min()
      |                                 ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh:66:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
   66 |     return lhs.min() <= rhs.min() ? lhs.max() >= rhs.min()
      |                                                          ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh:67:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
   67 |                                   : lhs.min() <= rhs.max();
      |                                                          ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
In file included from selection.cc:3:
buffer_utils.hh: In function 'bool Kakoune::is_bow(const Buffer&, BufferCoord)':
buffer_utils.hh:54:33: warning: C++20 says that these are ambiguous, even though the second is reversed:
   54 |     if (coord == BufferCoord{0,0})
      |                                 ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer_utils.hh: In function 'bool Kakoune::is_eow(const Buffer&, BufferCoord)':
buffer_utils.hh:62:57: warning: C++20 says that these are ambiguous, even though the second is reversed:
   62 |     if (buffer.is_end(coord) or coord == BufferCoord{0,0})
      |                                                         ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.cc: In function 'bool Kakoune::compare_selections(const Selection&, const Selection&)':
selection.cc:58:20: warning: C++20 says that these are ambiguous, even though the second is reversed:
   58 |     return lmin == rmin ? lhs.max() < rhs.max() : lmin < rmin;
      |                    ^~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.cc:58:47: warning: C++20 says that these are ambiguous, even though the second is reversed:
   58 |     return lmin == rmin ? lhs.max() < rhs.max() : lmin < rmin;
      |                                               ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.cc:58:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
   58 |     return lmin == rmin ? lhs.max() < rhs.max() : lmin < rmin;
      |                                                          ^~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.cc: In function 'Kakoune::BufferCoord Kakoune::{anonymous}::update_insert(Kakoune::BufferCoord, Kakoune::BufferCoord, Kakoune::BufferCoord)':
selection.cc:66:17: warning: C++20 says that these are ambiguous, even though the second is reversed:
   66 |     if (coord < begin)
      |                 ^~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.cc: In lambda function:
selection.cc:190:29: warning: C++20 says that these are ambiguous, even though the second is reversed:
  190 |         return lhs.max() == end_coord or buffer.char_next(lhs.max()) >= rhs.min();
      |                             ^~~~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.cc:190:81: warning: C++20 says that these are ambiguous, even though the second is reversed:
  190 |         return lhs.max() == end_coord or buffer.char_next(lhs.max()) >= rhs.min();
      |                                                                                 ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.cc: In function 'Kakoune::Vector<Kakoune::Selection> Kakoune::compute_modified_ranges(const Buffer&, size_t)':
selection.cc:205:40: warning: C++20 says that these are ambiguous, even though the second is reversed:
  205 |         if (sel.anchor() != sel.cursor())
      |                                        ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.cc: In lambda function:
selection.cc:309:22: warning: C++20 says that these are ambiguous, even though the second is reversed:
  309 |         if (begin == main_begin)
      |                      ^~~~~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.cc:312:28: warning: C++20 says that these are ambiguous, even though the second is reversed:
  312 |             return begin < main_begin;
      |                            ^~~~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.cc: In lambda function:
selection.cc:342:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
  342 |         return m_buffer->char_next(lhs.max()) >= rhs.min();
      |                                                          ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.cc: In function 'void Kakoune::replace(Buffer&, Selection&, StringView)':
selection.cc:399:29: warning: C++20 says that these are ambiguous, even though the second is reversed:
  399 |     max = range.end > range.begin ? buffer.char_prev(range.end) : range.begin;
      |                             ^~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
In file included from selection.cc:4:
changes.hh: In instantiation of 'auto Kakoune::update_range(ForwardChangesTracker&, Range&, AdvanceFunc&&) [with Range = Selection; AdvanceFunc = update_forward<std::vector<Selection, Allocator<Selection, Kakoune::MemoryDomain::Selections> > >(ConstArrayView<Buffer::Change>, std::vector<Selection, Allocator<Selection, Kakoune::MemoryDomain::Selections> >&)::<lambda(const BufferCoord&)>&]':
changes.hh:59:21:   required from 'void Kakoune::update_forward(ConstArrayView<Buffer::Change>, RangeContainer&) [with RangeContainer = std::vector<Selection, Allocator<Selection, Kakoune::MemoryDomain::Selections> >; ConstArrayView<Buffer::Change> = ArrayView<const Buffer::Change>]'
selection.cc:139:27:   required from here
changes.hh:39:14: warning: C++20 says that these are ambiguous, even though the second is reversed:
   39 |     if (last < BufferCoord{0,0})
      |         ~~~~~^~~~~~~~~~~~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
changes.hh: In instantiation of 'auto Kakoune::update_range(ForwardChangesTracker&, Range&, AdvanceFunc&&) [with Range = Selection; AdvanceFunc = update_backward<std::vector<Selection, Allocator<Selection, Kakoune::MemoryDomain::Selections> > >(ConstArrayView<Buffer::Change>, std::vector<Selection, Allocator<Selection, Kakoune::MemoryDomain::Selections> >&)::<lambda(const BufferCoord&)>&]':
changes.hh:81:21:   required from 'void Kakoune::update_backward(ConstArrayView<Buffer::Change>, RangeContainer&) [with RangeContainer = std::vector<Selection, Allocator<Selection, Kakoune::MemoryDomain::Selections> >; ConstArrayView<Buffer::Change> = ArrayView<const Buffer::Change>]'
selection.cc:155:28:   required from here
changes.hh:39:14: warning: C++20 says that these are ambiguous, even though the second is reversed:
   39 |     if (last < BufferCoord{0,0})
      |         ~~~~~^~~~~~~~~~~~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
changes.hh: In instantiation of 'Kakoune::update_forward<std::vector<Selection, Allocator<Selection, Kakoune::MemoryDomain::Selections> > >(ConstArrayView<Buffer::Change>, std::vector<Selection, Allocator<Selection, Kakoune::MemoryDomain::Selections> >&)::<lambda(auto:69&, const Kakoune::Buffer::Change&)> [with auto:69 = Kakoune::Selection]':
/usr/include/c++/13/bits/predefined_ops.h:196:23:   required from 'constexpr bool __gnu_cxx::__ops::_Iter_comp_val<_Compare>::operator()(_Iterator, _Value&) [with _Iterator = __gnu_cxx::__normal_iterator<Kakoune::Selection*, std::vector<Kakoune::Selection, Kakoune::Allocator<Kakoune::Selection, Kakoune::MemoryDomain::Selections> > >; _Value = const Kakoune::Buffer::Change; _Compare = Kakoune::update_forward<std::vector<Selection, Allocator<Selection, Kakoune::MemoryDomain::Selections> > >(ConstArrayView<Buffer::Change>, std::vector<Selection, Allocator<Selection, Kakoune::MemoryDomain::Selections> >&)::<lambda(auto:69&, const Kakoune::Buffer::Change&)>]'
/usr/include/c++/13/bits/stl_algobase.h:1472:14:   required from 'constexpr _ForwardIterator std::__lower_bound(_ForwardIterator, _ForwardIterator, const _Tp&, _Compare) [with _ForwardIterator = __gnu_cxx::__normal_iterator<Kakoune::Selection*, vector<Kakoune::Selection, Kakoune::Allocator<Kakoune::Selection, Kakoune::MemoryDomain::Selections> > >; _Tp = Kakoune::Buffer::Change; _Compare = __gnu_cxx::__ops::_Iter_comp_val<Kakoune::update_forward<std::vector<Selection, Allocator<Selection, Kakoune::MemoryDomain::Selections> > >(ConstArrayView<Buffer::Change>, std::vector<Selection, Allocator<Selection, Kakoune::MemoryDomain::Selections> >&)::<lambda(auto:69&, const Kakoune::Buffer::Change&)> >]'
/usr/include/c++/13/bits/stl_algo.h:2015:32:   required from 'constexpr _FIter std::lower_bound(_FIter, _FIter, const _Tp&, _Compare) [with _FIter = __gnu_cxx::__normal_iterator<Kakoune::Selection*, vector<Kakoune::Selection, Kakoune::Allocator<Kakoune::Selection, Kakoune::MemoryDomain::Selections> > >; _Tp = Kakoune::Buffer::Change; _Compare = Kakoune::update_forward<std::vector<Selection, Allocator<Selection, Kakoune::MemoryDomain::Selections> > >(ConstArrayView<Buffer::Change>, std::vector<Selection, Allocator<Selection, Kakoune::MemoryDomain::Selections> >&)::<lambda(auto:69&, const Kakoune::Buffer::Change&)>]'
changes.hh:56:37:   required from 'void Kakoune::update_forward(ConstArrayView<Buffer::Change>, RangeContainer&) [with RangeContainer = std::vector<Selection, Allocator<Selection, Kakoune::MemoryDomain::Selections> >; ConstArrayView<Buffer::Change> = ArrayView<const Buffer::Change>]'
selection.cc:139:27:   required from here
changes.hh:57:109: warning: C++20 says that these are ambiguous, even though the second is reversed:
   57 |                                      [](auto& range, const Buffer::Change& change) { return get_last(range) < change.begin; });
      |                                                                                             ~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
make: Entering directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
g++  -O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer  -pedantic -std=c++2a -g -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-address -Wno-init-list-lifetime -MD -MP -MF .string_utils.opt.d -c -o .string_utils.opt.o string_utils.cc
make: Leaving directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
make: Entering directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
g++  -O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer  -pedantic -std=c++2a -g -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-address -Wno-init-list-lifetime -MD -MP -MF .main.opt.d -c -o .main.opt.o main.cc
make: Leaving directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
In file included from buffer.hh:310,
                 from main.cc:3:
buffer.inl.hh: In member function 'Kakoune::ByteCount Kakoune::Buffer::distance(Kakoune::BufferCoord, Kakoune::BufferCoord) const':
buffer.inl.hh:32:17: warning: C++20 says that these are ambiguous, even though the second is reversed:
   32 |     if (begin > end)
      |                 ^~~
In file included from buffer.hh:5:
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::Buffer::is_end(Kakoune::BufferCoord) const':
buffer.inl.hh:53:27: warning: C++20 says that these are ambiguous, even though the second is reversed:
   53 |     return c >= end_coord();
      |                           ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferIterator&) const':
buffer.inl.hh:107:66: warning: C++20 says that these are ambiguous, even though the second is reversed:
  107 |     return m_buffer == iterator.m_buffer and m_coord == iterator.m_coord;
      |                                                                  ^~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'std::strong_ordering Kakoune::BufferIterator::operator<=>(const Kakoune::BufferIterator&) const':
buffer.inl.hh:113:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
  113 |     return (m_coord <=> iterator.m_coord);
      |                                  ^~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferCoord&) const':
buffer.inl.hh:118:23: warning: C++20 says that these are ambiguous, even though the second is reversed:
  118 |     return m_coord == coord;
      |                       ^~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
In file included from buffer_utils.hh:5,
                 from main.cc:5:
selection.hh: In member function 'bool Kakoune::Selection::operator==(const Kakoune::Selection&) const':
selection.hh:47:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
   47 |         return m_anchor == other.m_anchor and m_cursor == other.m_cursor;
      |                                  ^~~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'Kakoune::BufferCoord& Kakoune::Selection::min()':
selection.hh:54:45: warning: C++20 says that these are ambiguous, even though the second is reversed:
   54 |     BufferCoord& min() { return m_anchor <= m_cursor ? m_anchor : m_cursor; }
      |                                             ^~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'Kakoune::BufferCoord& Kakoune::Selection::max()':
selection.hh:55:45: warning: C++20 says that these are ambiguous, even though the second is reversed:
   55 |     BufferCoord& max() { return m_anchor <= m_cursor ? m_cursor : m_anchor; }
      |                                             ^~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In function 'bool Kakoune::overlaps(const Selection&, const Selection&)':
selection.hh:66:33: warning: C++20 says that these are ambiguous, even though the second is reversed:
   66 |     return lhs.min() <= rhs.min() ? lhs.max() >= rhs.min()
      |                                 ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh:66:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
   66 |     return lhs.min() <= rhs.min() ? lhs.max() >= rhs.min()
      |                                                          ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh:67:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
   67 |                                   : lhs.min() <= rhs.max();
      |                                                          ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer_utils.hh: In function 'bool Kakoune::is_bow(const Buffer&, BufferCoord)':
buffer_utils.hh:54:33: warning: C++20 says that these are ambiguous, even though the second is reversed:
   54 |     if (coord == BufferCoord{0,0})
      |                                 ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer_utils.hh: In function 'bool Kakoune::is_eow(const Buffer&, BufferCoord)':
buffer_utils.hh:62:57: warning: C++20 says that these are ambiguous, even though the second is reversed:
   62 |     if (buffer.is_end(coord) or coord == BufferCoord{0,0})
      |                                                         ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
In file included from main.cc:13:
highlighters.hh: In function 'bool Kakoune::operator==(const InclusiveBufferRange&, const InclusiveBufferRange&)':
highlighters.hh:17:29: warning: C++20 says that these are ambiguous, even though the second is reversed:
   17 |     return lhs.first == rhs.first and lhs.last == rhs.last;
      |                             ^~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.hh:17:55: warning: C++20 says that these are ambiguous, even though the second is reversed:
   17 |     return lhs.first == rhs.first and lhs.last == rhs.last;
      |                                                       ^~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
In file included from scope.hh:9,
                 from buffer.hh:12:
option_manager.hh: In instantiation of 'bool Kakoune::TypedOption<T>::has_same_value(const Kakoune::Option&) const [with T = Kakoune::DisplayCoord]':
option_manager.hh:189:10:   required from here
option_manager.hh:191:57: warning: C++20 says that these are ambiguous, even though the second is reversed:
  191 |         return other.is_of_type<T>() and other.get<T>() == m_value;
      |                                          ~~~~~~~~~~~~~~~^~~~~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::DisplayCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ColumnCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::DisplayCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ColumnCount]' (reversed)
option_manager.hh: In instantiation of 'void Kakoune::TypedOption<T>::set(T, bool) [with T = Kakoune::DisplayCoord]':
option_manager.hh:169:9:   required from 'void Kakoune::TypedOption<T>::set_from_strings(Kakoune::ConstArrayView<Kakoune::String>) [with T = Kakoune::DisplayCoord; Kakoune::ConstArrayView<Kakoune::String> = Kakoune::ArrayView<const Kakoune::String>]'
option_manager.hh:167:10:   required from here
option_manager.hh:139:21: warning: C++20 says that these are ambiguous, even though the second is reversed:
  139 |         if (m_value != value)
      |             ~~~~~~~~^~~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::DisplayCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ColumnCount]' (rewritten)
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::DisplayCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ColumnCount]' (reversed)
make: Entering directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
g++  -O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer  -pedantic -std=c++2a -g -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-address -Wno-init-list-lifetime -MD -MP -MF .unit_tests.opt.d -c -o .unit_tests.opt.o unit_tests.cc
make: Leaving directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
make: Entering directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
g++  -O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer  -pedantic -std=c++2a -g -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-address -Wno-init-list-lifetime -c -o .version.o .version.cc
make: Leaving directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
make: Entering directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
g++  -O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer  -pedantic -std=c++2a -g -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-address -Wno-init-list-lifetime -MD -MP -MF .shell_manager.opt.d -c -o .shell_manager.opt.o shell_manager.cc
make: Leaving directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
In file included from buffer.hh:310,
                 from buffer_utils.hh:4,
                 from shell_manager.cc:3:
buffer.inl.hh: In member function 'Kakoune::ByteCount Kakoune::Buffer::distance(Kakoune::BufferCoord, Kakoune::BufferCoord) const':
buffer.inl.hh:32:17: warning: C++20 says that these are ambiguous, even though the second is reversed:
   32 |     if (begin > end)
      |                 ^~~
In file included from buffer.hh:5:
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::Buffer::is_end(Kakoune::BufferCoord) const':
buffer.inl.hh:53:27: warning: C++20 says that these are ambiguous, even though the second is reversed:
   53 |     return c >= end_coord();
      |                           ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferIterator&) const':
buffer.inl.hh:107:66: warning: C++20 says that these are ambiguous, even though the second is reversed:
  107 |     return m_buffer == iterator.m_buffer and m_coord == iterator.m_coord;
      |                                                                  ^~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'std::strong_ordering Kakoune::BufferIterator::operator<=>(const Kakoune::BufferIterator&) const':
buffer.inl.hh:113:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
  113 |     return (m_coord <=> iterator.m_coord);
      |                                  ^~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferCoord&) const':
buffer.inl.hh:118:23: warning: C++20 says that these are ambiguous, even though the second is reversed:
  118 |     return m_coord == coord;
      |                       ^~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
In file included from buffer_utils.hh:5:
selection.hh: In member function 'bool Kakoune::Selection::operator==(const Kakoune::Selection&) const':
selection.hh:47:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
   47 |         return m_anchor == other.m_anchor and m_cursor == other.m_cursor;
      |                                  ^~~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'Kakoune::BufferCoord& Kakoune::Selection::min()':
selection.hh:54:45: warning: C++20 says that these are ambiguous, even though the second is reversed:
   54 |     BufferCoord& min() { return m_anchor <= m_cursor ? m_anchor : m_cursor; }
      |                                             ^~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'Kakoune::BufferCoord& Kakoune::Selection::max()':
selection.hh:55:45: warning: C++20 says that these are ambiguous, even though the second is reversed:
   55 |     BufferCoord& max() { return m_anchor <= m_cursor ? m_cursor : m_anchor; }
      |                                             ^~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In function 'bool Kakoune::overlaps(const Selection&, const Selection&)':
selection.hh:66:33: warning: C++20 says that these are ambiguous, even though the second is reversed:
   66 |     return lhs.min() <= rhs.min() ? lhs.max() >= rhs.min()
      |                                 ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh:66:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
   66 |     return lhs.min() <= rhs.min() ? lhs.max() >= rhs.min()
      |                                                          ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh:67:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
   67 |                                   : lhs.min() <= rhs.max();
      |                                                          ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer_utils.hh: In function 'bool Kakoune::is_bow(const Buffer&, BufferCoord)':
buffer_utils.hh:54:33: warning: C++20 says that these are ambiguous, even though the second is reversed:
   54 |     if (coord == BufferCoord{0,0})
      |                                 ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer_utils.hh: In function 'bool Kakoune::is_eow(const Buffer&, BufferCoord)':
buffer_utils.hh:62:57: warning: C++20 says that these are ambiguous, even though the second is reversed:
   62 |     if (buffer.is_end(coord) or coord == BufferCoord{0,0})
      |                                                         ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
shell_manager.cc: In lambda function:
shell_manager.cc:228:20: warning: ignoring return value of 'char* mkdtemp(char*)' declared with attribute 'warn_unused_result' [-Wunused-result]
  228 |             mkdtemp(base_dir.data()),
      |             ~~~~~~~^~~~~~~~~~~~~~~~~
make: Entering directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
g++  -O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer  -pedantic -std=c++2a -g -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-address -Wno-init-list-lifetime -MD -MP -MF .selectors.opt.d -c -o .selectors.opt.o selectors.cc
make: Leaving directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
In file included from buffer.hh:310,
                 from buffer_utils.hh:4,
                 from selectors.cc:3:
buffer.inl.hh: In member function 'Kakoune::ByteCount Kakoune::Buffer::distance(Kakoune::BufferCoord, Kakoune::BufferCoord) const':
buffer.inl.hh:32:17: warning: C++20 says that these are ambiguous, even though the second is reversed:
   32 |     if (begin > end)
      |                 ^~~
In file included from buffer.hh:5:
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::Buffer::is_end(Kakoune::BufferCoord) const':
buffer.inl.hh:53:27: warning: C++20 says that these are ambiguous, even though the second is reversed:
   53 |     return c >= end_coord();
      |                           ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferIterator&) const':
buffer.inl.hh:107:66: warning: C++20 says that these are ambiguous, even though the second is reversed:
  107 |     return m_buffer == iterator.m_buffer and m_coord == iterator.m_coord;
      |                                                                  ^~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'std::strong_ordering Kakoune::BufferIterator::operator<=>(const Kakoune::BufferIterator&) const':
buffer.inl.hh:113:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
  113 |     return (m_coord <=> iterator.m_coord);
      |                                  ^~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferCoord&) const':
buffer.inl.hh:118:23: warning: C++20 says that these are ambiguous, even though the second is reversed:
  118 |     return m_coord == coord;
      |                       ^~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
In file included from buffer_utils.hh:5:
selection.hh: In member function 'bool Kakoune::Selection::operator==(const Kakoune::Selection&) const':
selection.hh:47:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
   47 |         return m_anchor == other.m_anchor and m_cursor == other.m_cursor;
      |                                  ^~~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'Kakoune::BufferCoord& Kakoune::Selection::min()':
selection.hh:54:45: warning: C++20 says that these are ambiguous, even though the second is reversed:
   54 |     BufferCoord& min() { return m_anchor <= m_cursor ? m_anchor : m_cursor; }
      |                                             ^~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'Kakoune::BufferCoord& Kakoune::Selection::max()':
selection.hh:55:45: warning: C++20 says that these are ambiguous, even though the second is reversed:
   55 |     BufferCoord& max() { return m_anchor <= m_cursor ? m_cursor : m_anchor; }
      |                                             ^~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In function 'bool Kakoune::overlaps(const Selection&, const Selection&)':
selection.hh:66:33: warning: C++20 says that these are ambiguous, even though the second is reversed:
   66 |     return lhs.min() <= rhs.min() ? lhs.max() >= rhs.min()
      |                                 ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh:66:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
   66 |     return lhs.min() <= rhs.min() ? lhs.max() >= rhs.min()
      |                                                          ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh:67:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
   67 |                                   : lhs.min() <= rhs.max();
      |                                                          ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer_utils.hh: In function 'bool Kakoune::is_bow(const Buffer&, BufferCoord)':
buffer_utils.hh:54:33: warning: C++20 says that these are ambiguous, even though the second is reversed:
   54 |     if (coord == BufferCoord{0,0})
      |                                 ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer_utils.hh: In function 'bool Kakoune::is_eow(const Buffer&, BufferCoord)':
buffer_utils.hh:62:57: warning: C++20 says that these are ambiguous, even though the second is reversed:
   62 |     if (buffer.is_end(coord) or coord == BufferCoord{0,0})
      |                                                         ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selectors.cc: In function 'Kakoune::Selection Kakoune::keep_direction(Selection, const Selection&)':
selectors.cc:42:36: warning: C++20 says that these are ambiguous, even though the second is reversed:
   42 |     if ((res.cursor() < res.anchor()) != (ref.cursor() < ref.anchor()))
      |                                    ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selectors.cc: In function 'Kakoune::Optional<Kakoune::Selection> Kakoune::select_surrounding(const Context&, const Selection&, const Regex&, const Regex&, int, ObjectFlags)':
selectors.cc:389:46: warning: C++20 says that these are ambiguous, even though the second is reversed:
  389 |         (res->first.coord() == selection.min() or not (flags & ObjectFlags::ToBegin)) and
      |                                              ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selectors.cc:390:47: warning: C++20 says that these are ambiguous, even though the second is reversed:
  390 |         (res->second.coord() == selection.max() or not (flags & ObjectFlags::ToEnd)))
      |                                               ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selectors.cc: In function 'Kakoune::Optional<Kakoune::Selection> Kakoune::select_paragraph(const Context&, const Selection&, int, ObjectFlags)':
selectors.cc:557:81: warning: C++20 says that these are ambiguous, even though the second is reversed:
  557 |         if (not (flags & ObjectFlags::ToEnd) and first.coord() > BufferCoord{0,1} and
      |                                                                                 ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selectors.cc: In function 'Kakoune::Optional<Kakoune::Selection> Kakoune::select_lines(const Context&, const Selection&)':
selectors.cc:817:44: warning: C++20 says that these are ambiguous, even though the second is reversed:
  817 |     BufferCoord& to_line_start = anchor <= cursor ? anchor : cursor;
      |                                            ^~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selectors.cc:818:42: warning: C++20 says that these are ambiguous, even though the second is reversed:
  818 |     BufferCoord& to_line_end = anchor <= cursor ? cursor : anchor;
      |                                          ^~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selectors.cc: In function 'Kakoune::Optional<Kakoune::Selection> Kakoune::trim_partial_lines(const Context&, const Selection&)':
selectors.cc:832:44: warning: C++20 says that these are ambiguous, even though the second is reversed:
  832 |     BufferCoord& to_line_start = anchor <= cursor ? anchor : cursor;
      |                                            ^~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selectors.cc:833:42: warning: C++20 says that these are ambiguous, even though the second is reversed:
  833 |     BufferCoord& to_line_end = anchor <= cursor ? cursor : anchor;
      |                                          ^~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selectors.cc:846:25: warning: C++20 says that these are ambiguous, even though the second is reversed:
  846 |     if (to_line_start > to_line_end)
      |                         ^~~~~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
In file included from memory.hh:8,
                 from string.hh:4,
                 from enum.hh:4,
                 from selectors.hh:4,
                 from selectors.cc:1:
selectors.cc: In function 'Kakoune::Vector<Kakoune::Selection, Kakoune::MemoryDomain::Selections> Kakoune::select_matches(const Buffer&, ConstArrayView<Selection>, const Regex&, int)':
selectors.cc:945:77: warning: C++20 says that these are ambiguous, even though the second is reversed:
  945 |             kak_assert(result.empty() or begin.coord() >= result.back().min());
      |                                                                             ^
assert.hh:33:47: note: in definition of macro 'kak_assert'
   33 |     #define kak_assert(...) do { (void)sizeof(__VA_ARGS__); } while(false)
      |                                               ^~~~~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selectors.cc: In function 'Kakoune::Vector<Kakoune::Selection, Kakoune::MemoryDomain::Selections> Kakoune::split_on_matches(const Buffer&, ConstArrayView<Selection>, const Regex&, int)':
selectors.cc:985:38: warning: C++20 says that these are ambiguous, even though the second is reversed:
  985 |         if (begin.coord() <= sel.max())
      |                                      ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selectors.cc: In instantiation of 'Kakoune::Optional<Kakoune::Selection> Kakoune::select_to_line_end(const Context&, const Selection&) [with bool only_move = false]':
selectors.cc:189:88:   required from here
selectors.cc:185:13: warning: C++20 says that these are ambiguous, even though the second is reversed:
  185 |     if (end < begin) // Do not go backward when cursor is on eol
      |         ~~~~^~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selectors.cc: In instantiation of 'Kakoune::Optional<Kakoune::Selection> Kakoune::select_to_line_end(const Context&, const Selection&) [with bool only_move = true]':
selectors.cc:190:87:   required from here
selectors.cc:185:13: warning: C++20 says that these are ambiguous, even though the second is reversed:
  185 |     if (end < begin) // Do not go backward when cursor is on eol
      |         ~~~~^~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
make: Entering directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
g++  -O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer  -pedantic -std=c++2a -g -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-address -Wno-init-list-lifetime -MD -MP -MF .terminal_ui.opt.d -c -o .terminal_ui.opt.o terminal_ui.cc
terminal_ui.cc: In function 'Kakoune::String Kakoune::fix_atom_text(StringView)':
terminal_ui.cc:33:15: warning: comparison is always true due to limited range of data type [-Wtype-limits]
   33 |         if (c >= 0 and c <= 0x1F)
      |             ~~^~~~
terminal_ui.cc: In function 'Kakoune::DisplayCoord Kakoune::compute_pos(DisplayCoord, DisplayCoord, TerminalUI::Rect, TerminalUI::Rect, bool)':
terminal_ui.cc:1194:39: warning: C++20 says that these are ambiguous, even though the second is reversed:
 1194 |     if (to_avoid.size != DisplayCoord{})
      |                                       ^
In file included from terminal_ui.hh:5,
                 from terminal_ui.cc:1:
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::DisplayCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ColumnCount]' (rewritten)
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::DisplayCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ColumnCount]' (reversed)
make: Leaving directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
make: Entering directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
g++  -O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer  -pedantic -std=c++2a -g -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-address -Wno-init-list-lifetime -MD -MP -MF .word_db.opt.d -c -o .word_db.opt.o word_db.cc
make: Leaving directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
In file included from buffer.hh:310,
                 from word_db.cc:3:
buffer.inl.hh: In member function 'Kakoune::ByteCount Kakoune::Buffer::distance(Kakoune::BufferCoord, Kakoune::BufferCoord) const':
buffer.inl.hh:32:17: warning: C++20 says that these are ambiguous, even though the second is reversed:
   32 |     if (begin > end)
      |                 ^~~
In file included from buffer.hh:5:
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::Buffer::is_end(Kakoune::BufferCoord) const':
buffer.inl.hh:53:27: warning: C++20 says that these are ambiguous, even though the second is reversed:
   53 |     return c >= end_coord();
      |                           ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferIterator&) const':
buffer.inl.hh:107:66: warning: C++20 says that these are ambiguous, even though the second is reversed:
  107 |     return m_buffer == iterator.m_buffer and m_coord == iterator.m_coord;
      |                                                                  ^~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'std::strong_ordering Kakoune::BufferIterator::operator<=>(const Kakoune::BufferIterator&) const':
buffer.inl.hh:113:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
  113 |     return (m_coord <=> iterator.m_coord);
      |                                  ^~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferCoord&) const':
buffer.inl.hh:118:23: warning: C++20 says that these are ambiguous, even though the second is reversed:
  118 |     return m_coord == coord;
      |                       ^~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
make: Entering directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
g++  -O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer  -pedantic -std=c++2a -g -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-address -Wno-init-list-lifetime -MD -MP -MF .window.opt.d -c -o .window.opt.o window.cc
In file included from buffer.hh:310,
                 from selection.hh:4,
                 from context.hh:4,
                 from input_handler.hh:6,
                 from client.hh:7,
                 from window.hh:4,
                 from window.cc:1:
buffer.inl.hh: In member function 'Kakoune::ByteCount Kakoune::Buffer::distance(Kakoune::BufferCoord, Kakoune::BufferCoord) const':
buffer.inl.hh:32:17: warning: C++20 says that these are ambiguous, even though the second is reversed:
   32 |     if (begin > end)
      |                 ^~~
In file included from display_buffer.hh:6,
                 from client.hh:5:
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::Buffer::is_end(Kakoune::BufferCoord) const':
buffer.inl.hh:53:27: warning: C++20 says that these are ambiguous, even though the second is reversed:
   53 |     return c >= end_coord();
      |                           ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferIterator&) const':
buffer.inl.hh:107:66: warning: C++20 says that these are ambiguous, even though the second is reversed:
  107 |     return m_buffer == iterator.m_buffer and m_coord == iterator.m_coord;
      |                                                                  ^~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'std::strong_ordering Kakoune::BufferIterator::operator<=>(const Kakoune::BufferIterator&) const':
buffer.inl.hh:113:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
  113 |     return (m_coord <=> iterator.m_coord);
      |                                  ^~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferCoord&) const':
buffer.inl.hh:118:23: warning: C++20 says that these are ambiguous, even though the second is reversed:
  118 |     return m_coord == coord;
      |                       ^~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'bool Kakoune::Selection::operator==(const Kakoune::Selection&) const':
selection.hh:47:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
   47 |         return m_anchor == other.m_anchor and m_cursor == other.m_cursor;
      |                                  ^~~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'Kakoune::BufferCoord& Kakoune::Selection::min()':
selection.hh:54:45: warning: C++20 says that these are ambiguous, even though the second is reversed:
   54 |     BufferCoord& min() { return m_anchor <= m_cursor ? m_anchor : m_cursor; }
      |                                             ^~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'Kakoune::BufferCoord& Kakoune::Selection::max()':
selection.hh:55:45: warning: C++20 says that these are ambiguous, even though the second is reversed:
   55 |     BufferCoord& max() { return m_anchor <= m_cursor ? m_cursor : m_anchor; }
      |                                             ^~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In function 'bool Kakoune::overlaps(const Selection&, const Selection&)':
selection.hh:66:33: warning: C++20 says that these are ambiguous, even though the second is reversed:
   66 |     return lhs.min() <= rhs.min() ? lhs.max() >= rhs.min()
      |make: Leaving directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
                                 ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh:66:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
   66 |     return lhs.min() <= rhs.min() ? lhs.max() >= rhs.min()
      |                                                          ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh:67:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
   67 |                                   : lhs.min() <= rhs.max();
      |                                                          ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
In file included from window.cc:10:
buffer_utils.hh: In function 'bool Kakoune::is_bow(const Buffer&, BufferCoord)':
buffer_utils.hh:54:33: warning: C++20 says that these are ambiguous, even though the second is reversed:
   54 |     if (coord == BufferCoord{0,0})
      |                                 ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer_utils.hh: In function 'bool Kakoune::is_eow(const Buffer&, BufferCoord)':
buffer_utils.hh:62:57: warning: C++20 says that these are ambiguous, even though the second is reversed:
   62 |     if (buffer.is_end(coord) or coord == BufferCoord{0,0})
      |                                                         ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
window.cc: In member function 'bool Kakoune::Window::needs_redraw(const Kakoune::Context&) const':
window.cc:102:36: warning: C++20 says that these are ambiguous, even though the second is reversed:
  102 |     if (m_position != m_last_setup.position or
      |                                    ^~~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::DisplayCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ColumnCount]' (rewritten)
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::DisplayCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ColumnCount]' (reversed)
window.cc:103:38: warning: C++20 says that these are ambiguous, even though the second is reversed:
  103 |         m_dimensions != m_last_setup.dimensions or
      |                                      ^~~~~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::DisplayCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ColumnCount]' (rewritten)
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::DisplayCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ColumnCount]' (reversed)
window.cc:113:66: warning: C++20 says that these are ambiguous, even though the second is reversed:
  113 |             selections[i].anchor() != m_last_setup.selections[i].end)
      |                                                                  ^~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
window.cc: In member function 'const Kakoune::DisplayBuffer& Kakoune::Window::update_display_buffer(const Kakoune::Context&)':
window.cc:142:41: warning: C++20 says that these are ambiguous, even though the second is reversed:
  142 |     if (m_dimensions == DisplayCoord{0,0})
      |                                         ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::DisplayCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ColumnCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::DisplayCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ColumnCount]' (reversed)
window.cc: In member function 'void Kakoune::Window::set_dimensions(Kakoune::DisplayCoord)':
window.cc:188:25: warning: C++20 says that these are ambiguous, even though the second is reversed:
  188 |     if (m_dimensions != dimensions)
      |                         ^~~~~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::DisplayCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ColumnCount]' (rewritten)
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::DisplayCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ColumnCount]' (reversed)
window.cc: In function 'Kakoune::ColumnCount Kakoune::{anonymous}::find_display_column(const Kakoune::DisplayLine&, const Kakoune::Buffer&, Kakoune::BufferCoord)':
window.cc:272:33: warning: C++20 says that these are ambiguous, even though the second is reversed:
  272 |             coord >= atom.begin() and coord < atom.end())
      |                                 ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
window.cc:272:56: warning: C++20 says that these are ambiguous, even though the second is reversed:
  272 |             coord >= atom.begin() and coord < atom.end())
      |                                                        ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
window.cc: In function 'Kakoune::BufferCoord Kakoune::{anonymous}::find_buffer_coord(const Kakoune::DisplayLine&, const Kakoune::Buffer&, Kakoune::ColumnCount)':
window.cc:302:40: warning: C++20 says that these are ambiguous, even though the second is reversed:
  302 |     return range.end == BufferCoord{0,0} ?
      |                                        ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
window.cc: In member function 'Kakoune::Optional<Kakoune::DisplayCoord> Kakoune::Window::display_position(Kakoune::BufferCoord) const':
window.cc:316:28: warning: C++20 says that these are ambiguous, even though the second is reversed:
  316 |         if (range.begin <= coord and coord < range.end)
      |                            ^~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
window.cc:316:52: warning: C++20 says that these are ambiguous, even though the second is reversed:
  316 |         if (range.begin <= coord and coord < range.end)
      |                                                    ^~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
make: Entering directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
g++  -O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer  -pedantic -std=c++2a -g -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-address -Wno-init-list-lifetime -MD -MP -MF .normal.opt.d -c -o .normal.opt.o normal.cc
make: Leaving directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
In file included from buffer.hh:310,
                 from normal.cc:3:
buffer.inl.hh: In member function 'Kakoune::ByteCount Kakoune::Buffer::distance(Kakoune::BufferCoord, Kakoune::BufferCoord) const':
buffer.inl.hh:32:17: warning: C++20 says that these are ambiguous, even though the second is reversed:
   32 |     if (begin > end)
      |                 ^~~
In file included from keys.hh:4,
                 from normal.hh:5,
                 from normal.cc:1:
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::Buffer::is_end(Kakoune::BufferCoord) const':
buffer.inl.hh:53:27: warning: C++20 says that these are ambiguous, even though the second is reversed:
   53 |     return c >= end_coord();
      |                           ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferIterator&) const':
buffer.inl.hh:107:66: warning: C++20 says that these are ambiguous, even though the second is reversed:
  107 |     return m_buffer == iterator.m_buffer and m_coord == iterator.m_coord;
      |                                                                  ^~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'std::strong_ordering Kakoune::BufferIterator::operator<=>(const Kakoune::BufferIterator&) const':
buffer.inl.hh:113:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
  113 |     return (m_coord <=> iterator.m_coord);
      |                                  ^~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferCoord&) const':
buffer.inl.hh:118:23: warning: C++20 says that these are ambiguous, even though the second is reversed:
  118 |     return m_coord == coord;
      |                       ^~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
In file included from buffer_utils.hh:5,
                 from normal.cc:5:
selection.hh: In member function 'bool Kakoune::Selection::operator==(const Kakoune::Selection&) const':
selection.hh:47:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
   47 |         return m_anchor == other.m_anchor and m_cursor == other.m_cursor;
      |                                  ^~~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'Kakoune::BufferCoord& Kakoune::Selection::min()':
selection.hh:54:45: warning: C++20 says that these are ambiguous, even though the second is reversed:
   54 |     BufferCoord& min() { return m_anchor <= m_cursor ? m_anchor : m_cursor; }
      |                                             ^~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'Kakoune::BufferCoord& Kakoune::Selection::max()':
selection.hh:55:45: warning: C++20 says that these are ambiguous, even though the second is reversed:
   55 |     BufferCoord& max() { return m_anchor <= m_cursor ? m_cursor : m_anchor; }
      |                                             ^~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In function 'bool Kakoune::overlaps(const Selection&, const Selection&)':
selection.hh:66:33: warning: C++20 says that these are ambiguous, even though the second is reversed:
   66 |     return lhs.min() <= rhs.min() ? lhs.max() >= rhs.min()
      |                                 ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh:66:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
   66 |     return lhs.min() <= rhs.min() ? lhs.max() >= rhs.min()
      |                                                          ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh:67:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
   67 |                                   : lhs.min() <= rhs.max();
      |                                                          ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer_utils.hh: In function 'bool Kakoune::is_bow(const Buffer&, BufferCoord)':
buffer_utils.hh:54:33: warning: C++20 says that these are ambiguous, even though the second is reversed:
   54 |     if (coord == BufferCoord{0,0})
      |                                 ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer_utils.hh: In function 'bool Kakoune::is_eow(const Buffer&, BufferCoord)':
buffer_utils.hh:62:57: warning: C++20 says that these are ambiguous, even though the second is reversed:
   62 |     if (buffer.is_end(coord) or coord == BufferCoord{0,0})
      |                                                         ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
normal.cc: In function 'void Kakoune::merge_selections(Selection&, const Selection&)':
normal.cc:49:53: warning: C++20 says that these are ambiguous, even though the second is reversed:
   49 |     const bool forward = sel.cursor() >= sel.anchor();
      |                                                     ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
normal.cc:53:54: warning: C++20 says that these are ambiguous, even though the second is reversed:
   53 |     const bool backward = sel.cursor() <= sel.anchor();
      |                                                      ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
normal.cc: In function 'void Kakoune::select_boundaries(Context&, NormalParams)':
normal.cc:1076:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
 1076 |         if (sel.min() != sel.max())
      |                                  ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
normal.cc: In instantiation of 'void Kakoune::paste(Context&, NormalParams) [with PasteMode mode = Kakoune::PasteMode::Append]':
normal.cc:2382:1:   required from here
normal.cc:692:25: warning: C++20 says that these are ambiguous, even though the second is reversed:
  692 |         max = range.end > range.begin ? buffer.char_prev(range.end) : range.begin;
      |               ~~~~~~~~~~^~~~~~~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
normal.cc: In instantiation of 'void Kakoune::paste(Context&, NormalParams) [with PasteMode mode = Kakoune::PasteMode::Insert]':
normal.cc:2382:1:   required from here
normal.cc:692:25: warning: C++20 says that these are ambiguous, even though the second is reversed:
  692 |         max = range.end > range.begin ? buffer.char_prev(range.end) : range.begin;
      |               ~~~~~~~~~~^~~~~~~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
normal.cc: In instantiation of 'void Kakoune::goto_commands(Context&, NormalParams) [with SelectMode mode = Kakoune::SelectMode::Replace]':
normal.cc:2233:33:   required from here
normal.cc:329:26: warning: C++20 says that these are ambiguous, even though the second is reversed:
  329 |                 if (*pos >= buffer.back_coord())
      |                     ~~~~~^~~~~~~~~~~~~~~~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
normal.cc: In instantiation of 'void Kakoune::goto_commands(Context&, NormalParams) [with SelectMode mode = Kakoune::SelectMode::Extend]':
normal.cc:2234:37:   required from here
normal.cc:329:26: warning: C++20 says that these are ambiguous, even though the second is reversed:
  329 |                 if (*pos >= buffer.back_coord())
      |                     ~~~~~^~~~~~~~~~~~~~~~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
normal.cc: In instantiation of 'void Kakoune::paste(Context&, NormalParams) [with PasteMode mode = Kakoune::PasteMode::Replace]':
normal.cc:2244:57:   required from here
normal.cc:692:25: warning: C++20 says that these are ambiguous, even though the second is reversed:
  692 |         max = range.end > range.begin ? buffer.char_prev(range.end) : range.begin;
      |               ~~~~~~~~~~^~~~~~~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
normal.cc: In instantiation of 'void Kakoune::pipe(Context&, NormalParams) [with bool replace = true]':
normal.cc:2258:77:   required from here
normal.cc:592:33: warning: C++20 says that these are ambiguous, even though the second is reversed:
  592 |                     if (new_end != beg)
      |                         ~~~~~~~~^~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
normal.cc:596:37: warning: C++20 says that these are ambiguous, even though the second is reversed:
  596 |                         if (new_end != BufferCoord{})
      |                             ~~~~~~~~^~~~~~~~~~~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
normal.cc: In instantiation of 'void Kakoune::pipe(Context&, NormalParams) [with bool replace = false]':
normal.cc:2259:77:   required from here
normal.cc:592:33: warning: C++20 says that these are ambiguous, even though the second is reversed:
  592 |                     if (new_end != beg)
      |                         ~~~~~~~~^~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
normal.cc:596:37: warning: C++20 says that these are ambiguous, even though the second is reversed:
  596 |                         if (new_end != BufferCoord{})
      |                             ~~~~~~~~^~~~~~~~~~~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
normal.cc: In instantiation of 'void Kakoune::insert_output(Context&, NormalParams) [with PasteMode mode = Kakoune::PasteMode::Insert]':
normal.cc:2260:40:   required from here
normal.cc:778:33: warning: C++20 says that these are ambiguous, even though the second is reversed:
  778 |                 max = range.end > range.begin ? buffer.char_prev(range.end) : range.begin;
      |                       ~~~~~~~~~~^~~~~~~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
normal.cc: In instantiation of 'void Kakoune::insert_output(Context&, NormalParams) [with PasteMode mode = Kakoune::PasteMode::Append]':
normal.cc:2261:45:   required from here
normal.cc:778:33: warning: C++20 says that these are ambiguous, even though the second is reversed:
  778 |                 max = range.end > range.begin ? buffer.char_prev(range.end) : range.begin;
      |                       ~~~~~~~~~~^~~~~~~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
make: Entering directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
g++  -O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -fasynchronous-unwind-tables -fstack-clash-protection -fno-omit-frame-pointer  -pedantic -std=c++2a -g -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-address -Wno-init-list-lifetime -MD -MP -MF .highlighters.opt.d -c -o .highlighters.opt.o highlighters.cc
In file included from highlighters.cc:1:
highlighters.hh: In function 'bool Kakoune::operator==(const InclusiveBufferRange&, const InclusiveBufferRange&)':
highlighters.hh:17:29: warning: C++20 says that these are ambiguous, even though the second is reversed:
   17 |     return lhs.first == rhs.first and lhs.last == rhs.last;
      |                             ^~~~~
In file included from highlighter.hh:4,
                 from highlighters.hh:5:
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.hh:17:55: warning: C++20 says that these are ambiguous, even though the second is reversed:
   17 |     return lhs.first == rhs.first and lhs.last == rhs.last;
      |                                                       ^~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
In file included from buffer.hh:310,
                 from buffer_utils.hh:4,
                 from highlighters.cc:4:
buffer.inl.hh: In member function 'Kakoune::ByteCount Kakoune::Buffer::distance(Kakoune::BufferCoord, Kakoune::BufferCoord) const':
buffer.inl.hh:32:17: warning: C++20 says that these are ambiguous, even though the second is reversed:
   32 |     if (begin > end)
      |                 ^~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::Buffer::is_end(Kakoune::BufferCoord) const':
buffer.inl.hh:53:27: warning: C++20 says that these are ambiguous, even though the second is reversed:
   53 |     return c >= end_coord();
      |                           ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferIterator&) const':
buffer.inl.hh:107:66: warning: C++20 says that these are ambiguous, even though the second is reversed:
  107 |     return m_buffer == iterator.m_buffer and m_coord == iterator.m_coord;
      |                                                                  ^~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'std::strong_ordering Kakoune::BufferIterator::operator<=>(const Kakoune::BufferIterator&) const':
buffer.inl.hh:113:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
  113 |     return (m_coord <=> iterator.m_coord);
      |                                  ^~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer.inl.hh: In member function 'bool Kakoune::BufferIterator::operator==(const Kakoune::BufferCoord&) const':
buffer.inl.hh:118:23: warning: C++20 says that these are ambiguous, even though the second is reversed:
  118 |     return m_coord == coord;
      |                       ^~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
In file included from buffer_utils.hh:5:
selection.hh: In member function 'bool Kakoune::Selection::operator==(const Kakoune::Selection&) const':
selection.hh:47:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
   47 |         return m_anchor == other.m_anchor and m_cursor == other.m_cursor;
      |                                  ^~~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'Kakoune::BufferCoord& Kakoune::Selection::min()':
selection.hh:54:45: warning: C++20 says that these are ambiguous, even though the second is reversed:
   54 |     BufferCoord& min() { return m_anchor <= m_cursor ? m_anchor : m_cursor; }
      |                                             ^~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In member function 'Kakoune::BufferCoord& Kakoune::Selection::max()':
selection.hh:55:45: warning: C++20 says that these are ambiguous, even though the second is reversed:
   55 |     BufferCoord& max() { return m_anchor <= m_cursor ? m_cursor : m_anchor; }
      |                                             ^~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh: In function 'bool Kakoune::overlaps(const Selection&, const Selection&)':
selection.hh:66:33: warning: C++20 says that these are ambiguous, even though the second is reversed:
   66 |     return lhs.min() <= rhs.min() ? lhs.max() >= rhs.min()
      |                                 ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh:66:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
   66 |     return lhs.min() <= rhs.min() ? lhs.max() >= rhs.min()
      |                                                          ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
selection.hh:67:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
   67 |                                   : lhs.min() <= rhs.max();
      |                                                          ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer_utils.hh: In function 'bool Kakoune::is_bow(const Buffer&, BufferCoord)':
buffer_utils.hh:54:33: warning: C++20 says that these are ambiguous, even though the second is reversed:
   54 |     if (coord == BufferCoord{0,0})
      |                                 ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
buffer_utils.hh: In function 'bool Kakoune::is_eow(const Buffer&, BufferCoord)':
buffer_utils.hh:62:57: warning: C++20 says that these are ambiguous, even though the second is reversed:
   62 |     if (buffer.is_end(coord) or coord == BufferCoord{0,0})
      |                                                         ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc: In function 'void Kakoune::apply_highlighter(HighlightContext, DisplayBuffer&, BufferCoord, BufferCoord, Highlighter&)':
highlighters.cc:135:18: warning: C++20 says that these are ambiguous, even though the second is reversed:
  135 |     if (begin == end)
      |                  ^~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc:149:26: warning: C++20 says that these are ambiguous, even though the second is reversed:
  149 |         if (range.end <= begin or end <= range.begin)
      |                          ^~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc:149:48: warning: C++20 says that these are ambiguous, even though the second is reversed:
  149 |         if (range.end <= begin or end <= range.begin)
      |                                                ^~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc:155:27: warning: C++20 says that these are ambiguous, even though the second is reversed:
  155 |         if (range.begin < begin or range.end > end)
      |                           ^~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc:155:48: warning: C++20 says that these are ambiguous, even though the second is reversed:
  155 |         if (range.begin < begin or range.end > end)
      |                                                ^~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc:162:78: warning: C++20 says that these are ambiguous, even though the second is reversed:
  162 |                 if (not atom_it->has_buffer_range() or end <= atom_it->begin() or begin >= atom_it->end())
      |                                                                              ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc:162:105: warning: C++20 says that these are ambiguous, even though the second is reversed:
  162 |                 if (not atom_it->has_buffer_range() or end <= atom_it->begin() or begin >= atom_it->end())
      |                                                                                                         ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc:166:41: warning: C++20 says that these are ambiguous, even though the second is reversed:
  166 |                 if (atom_it->begin() <= begin)
      |                                         ^~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc:168:60: warning: C++20 says that these are ambiguous, even though the second is reversed:
  168 |                     if (is_replaced or atom_it->begin() == begin)
      |                                                            ^~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc:178:39: warning: C++20 says that these are ambiguous, even though the second is reversed:
  178 |                 if (atom_it->end() >= end)
      |                                       ^~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc:180:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
  180 |                     if (is_replaced or atom_it->end() == end)
      |                                                          ^~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc: In lambda function:
highlighters.cc:280:36: warning: C++20 says that these are ambiguous, even though the second is reversed:
  280 |             return lhs.begin < rhs.begin ? lhs.end > rhs.begin
      |                                    ^~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc:280:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
  280 |             return lhs.begin < rhs.begin ? lhs.end > rhs.begin
      |                                                          ^~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc:281:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
  281 |                                          : rhs.end > lhs.begin;
      |                                                          ^~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc: In lambda function:
highlighters.cc:410:61: warning: C++20 says that these are ambiguous, even though the second is reversed:
  410 |                                    { return lhs < rhs.range.end; });
      |                                                             ^~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc: In member function 'const Kakoune::RegexHighlighter::MatchList& Kakoune::RegexHighlighter::get_matches(const Kakoune::Buffer&, Kakoune::BufferRange, Kakoune::BufferRange)':
highlighters.cc:412:60: warning: C++20 says that these are ambiguous, even though the second is reversed:
  412 |         if (it == matches.end() or it->range.begin > range.end)
      |                                                            ^~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc:437:41: warning: C++20 says that these are ambiguous, even though the second is reversed:
  437 |             if (range.begin < old_range.begin)
      |                                         ^~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc:447:39: warning: C++20 says that these are ambiguous, even though the second is reversed:
  447 |             if (old_range.end < range.end)
      |                                       ^~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc: In member function 'virtual void Kakoune::WrapHighlighter::do_highlight(Kakoune::HighlightContext, Kakoune::DisplayBuffer&, Kakoune::BufferRange)':
highlighters.cc:732:44: warning: C++20 says that these are ambiguous, even though the second is reversed:
  732 |                     coord < atom_it->begin() or coord >= atom_it->end())
      |                                            ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc:732:71: warning: C++20 says that these are ambiguous, even though the second is reversed:
  732 |                     coord < atom_it->begin() or coord >= atom_it->end())
      |                                                                       ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc:740:44: warning: C++20 says that these are ambiguous, even though the second is reversed:
  740 |                 if (coord > atom_it->begin())
      |                                            ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc: In member function 'virtual void Kakoune::ShowWhitespacesHighlighter::do_highlight(Kakoune::HighlightContext, Kakoune::DisplayBuffer&, Kakoune::BufferRange)':
highlighters.cc:1080:50: warning: C++20 says that these are ambiguous, even though the second is reversed:
 1080 |                         if (coord != begin.coord())
      |                                                  ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc: In function 'void Kakoune::show_matching_char(HighlightContext, DisplayBuffer&, BufferRange)':
highlighters.cc:1237:25: warning: C++20 says that these are ambiguous, even though the second is reversed:
 1237 |         if (pos < range.begin or pos >= range.end)
      |                         ^~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc:1237:47: warning: C++20 says that these are ambiguous, even though the second is reversed:
 1237 |         if (pos < range.begin or pos >= range.end)
      |                                               ^~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc:1251:47: warning: C++20 says that these are ambiguous, even though the second is reversed:
 1251 |             while (it.base().coord() <= range.end)
      |                                               ^~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc:1264:30: warning: C++20 says that these are ambiguous, even though the second is reversed:
 1264 |         else if (pos > range.begin)
      |                              ^~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc:1278:48: warning: C++20 says that these are ambiguous, even though the second is reversed:
 1278 |                 if (it.base().coord() <= range.begin)
      |                                                ^~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc: In function 'void Kakoune::expand_unprintable(HighlightContext, DisplayBuffer&, BufferRange)':
highlighters.cc:1341:53: warning: C++20 says that these are ambiguous, even though the second is reversed:
 1341 |                         if (coord != atom_it->begin())
      |                                                     ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc:1343:55: warning: C++20 says that these are ambiguous, even though the second is reversed:
 1343 |                         if (it.coord() < atom_it->end())
      |                                                       ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc: In function 'bool Kakoune::is_empty(const InclusiveBufferRange&)':
highlighters.cc:1504:40: warning: C++20 says that these are ambiguous, even though the second is reversed:
 1504 |     return range.last < BufferCoord{0,0};
      |                                        ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc: In function 'bool Kakoune::option_element_compare(const RangeAndString&, const RangeAndString&)':
highlighters.cc:1578:55: warning: C++20 says that these are ambiguous, even though the second is reversed:
 1578 |     return std::get<0>(lhs).first == std::get<0>(rhs).first ?
      |                                                       ^~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc:1579:50: warning: C++20 says that these are ambiguous, even though the second is reversed:
 1579 |         std::get<0>(lhs).last < std::get<0>(rhs).last
      |                                                  ^~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc:1580:51: warning: C++20 says that these are ambiguous, even though the second is reversed:
 1580 |       : std::get<0>(lhs).first < std::get<0>(rhs).first;
      |                                                   ^~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc: In lambda function:
highlighters.cc:1653:139: warning: C++20 says that these are ambiguous, even though the second is reversed:
 1653 |         auto it = std::lower_bound(sels.begin(), sels.end(), range.first, [](const Selection& s, const BufferCoord& c) { return s.max() < c; });
      |                                                                                                                                           ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc: In static member function 'static bool Kakoune::ReplaceRangesHighlighter::is_fully_selected(const Kakoune::SelectionList&, const Kakoune::InclusiveBufferRange&)':
highlighters.cc:1656:34: warning: C++20 says that these are ambiguous, even though the second is reversed:
 1656 |         return it->min() > range.last or (it->min() <= range.first and it->max() >= range.last);
      |                                  ^~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc:1656:62: warning: C++20 says that these are ambiguous, even though the second is reversed:
 1656 |         return it->min() > range.last or (it->min() <= range.first and it->max() >= range.last);
      |                                                              ^~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc:1656:91: warning: C++20 says that these are ambiguous, even though the second is reversed:
 1656 |         return it->min() > range.last or (it->min() <= range.first and it->max() >= range.last);
      |                                                                                           ^~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc: In lambda function:
highlighters.cc:1889:91: warning: C++20 says that these are ambiguous, even though the second is reversed:
 1889 |                                       [](const Region& r, BufferCoord c) { return r.end < c; });
      |                                                                                           ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc: In lambda function:
highlighters.cc:1891:91: warning: C++20 says that these are ambiguous, even though the second is reversed:
 1891 |                                     [](const Region& r, BufferCoord c) { return r.begin < c; });
      |                                                                                           ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc: In member function 'virtual void Kakoune::RegionsHighlighter::do_highlight(Kakoune::HighlightContext, Kakoune::DisplayBuffer&, Kakoune::BufferRange)':
highlighters.cc:1906:55: warning: C++20 says that these are ambiguous, even though the second is reversed:
 1906 |             if (apply_default and last_begin < begin->begin)
      |                                                       ^~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc:1919:58: warning: C++20 says that these are ambiguous, even though the second is reversed:
 1919 |         if (apply_default and last_begin < display_range.end)
      |                                                          ^~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc: In static member function 'static bool Kakoune::RegionsHighlighter::compare_to_begin(const Kakoune::RegexMatch&, Kakoune::BufferCoord)':
highlighters.cc:2142:36: warning: C++20 says that these are ambiguous, even though the second is reversed:
 2142 |         return lhs.begin_coord() < rhs;
      |                                    ^~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc: In member function 'std::vector<Kakoune::RegexMatch, Kakoune::Allocator<Kakoune::RegexMatch, Kakoune::MemoryDomain::Regions> >::const_iterator Kakoune::RegionsHighlighter::find_matching_end(const Kakoune::Buffer&, Kakoune::BufferCoord, const Kakoune::RegexMatchList&, const Kakoune::RegexMatchList&, Kakoune::Optional<Kakoune::StringView>) const':
highlighters.cc:2161:61: warning: C++20 says that these are ambiguous, even though the second is reversed:
 2161 |                    rec_it->end_coord() <= end_it->end_coord())
      |                                                             ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc:2175:46: warning: C++20 says that these are ambiguous, even though the second is reversed:
 2175 |             if (beg_pos != end_it->end_coord())
      |                                              ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc: In member function 'Kakoune::Optional<std::pair<long unsigned int, __gnu_cxx::__normal_iterator<const Kakoune::RegexMatch*, std::vector<Kakoune::RegexMatch, Kakoune::Allocator<Kakoune::RegexMatch, Kakoune::MemoryDomain::Regions> > > > > Kakoune::RegionsHighlighter::find_next_begin(const Cache&, Kakoune::BufferCoord) const':
highlighters.cc:2194:98: warning: C++20 says that these are ambiguous, even though the second is reversed:
 2194 |             if (it != matches.end() and (not res or it->begin_coord() < res->second->begin_coord()))
      |                                                                                                  ^
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc: In member function 'const Kakoune::RegionsHighlighter::RegionList& Kakoune::RegionsHighlighter::get_regions_for_range(const Kakoune::Buffer&, Kakoune::BufferRange)':
highlighters.cc:2378:77: warning: C++20 says that these are ambiguous, even though the second is reversed:
 2378 |             if (end_it == end_matches.end() or end_it->end_coord() >= range.end) // region continue past range end
      |                                                                             ^~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc:2381:41: warning: C++20 says that these are ambiguous, even though the second is reversed:
 2381 |                 if (begin_coord < range.end)
      |                                         ^~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc:2392:50: warning: C++20 says that these are ambiguous, even though the second is reversed:
 2392 |             if (end_coord == beg_it->begin_coord())
      |                                                  ^
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc: In instantiation of 'void Kakoune::highlight_range(DisplayBuffer&, BufferCoord, BufferCoord, bool, T) [with T = <lambda(const Face&)>::<lambda(DisplayAtom&)>]':
highlighters.cc:237:24:   required from here
highlighters.cc:55:15: warning: C++20 says that these are ambiguous, even though the second is reversed:
   55 |     if (begin >= end or end <= display_buffer.range().begin
      |         ~~~~~~^~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc:55:29: warning: C++20 says that these are ambiguous, even though the second is reversed:
   55 |     if (begin >= end or end <= display_buffer.range().begin
      |                         ~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc:56:31: warning: C++20 says that these are ambiguous, even though the second is reversed:
   56 |                      or begin >= display_buffer.range().end)
      |                         ~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc:62:23: warning: C++20 says that these are ambiguous, even though the second is reversed:
   62 |         if (range.end <= begin or end < range.begin)
      |             ~~~~~~~~~~^~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc:62:39: warning: C++20 says that these are ambiguous, even though the second is reversed:
   62 |         if (range.end <= begin or end < range.begin)
      |                                   ~~~~^~~~~~~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc:71:21: warning: C++20 says that these are ambiguous, even though the second is reversed:
   71 |                 end <= atom_it->begin() or begin >= atom_it->end())
      |                 ~~~~^~~~~~~~~~~~~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc:71:50: warning: C++20 says that these are ambiguous, even though the second is reversed:
   71 |                 end <= atom_it->begin() or begin >= atom_it->end())
      |                                            ~~~~~~^~~~~~~~~~~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc:74:43: warning: C++20 says that these are ambiguous, even though the second is reversed:
   74 |             if (not is_replaced and begin > atom_it->begin())
      |                                     ~~~~~~^~~~~~~~~~~~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc:77:41: warning: C++20 says that these are ambiguous, even though the second is reversed:
   77 |             if (not is_replaced and end < atom_it->end())
      |                                     ~~~~^~~~~~~~~~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc: In instantiation of 'void Kakoune::replace_range(DisplayBuffer&, BufferCoord, BufferCoord, T) [with T = ReplaceRangesHighlighter::do_highlight(Kakoune::HighlightContext, Kakoune::DisplayBuffer&, Kakoune::BufferRange)::<lambda(DisplayLine&, DisplayLine::iterator)>]':
highlighters.cc:1674:30:   required from here
highlighters.cc:94:15: warning: C++20 says that these are ambiguous, even though the second is reversed:
   94 |     if (begin > end or end < display_buffer.range().begin or begin > display_buffer.range().end)
      |         ~~~~~~^~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc:94:28: warning: C++20 says that these are ambiguous, even though the second is reversed:
   94 |     if (begin > end or end < display_buffer.range().begin or begin > display_buffer.range().end)
      |                        ~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc:94:68: warning: C++20 says that these are ambiguous, even though the second is reversed:
   94 |     if (begin > end or end < display_buffer.range().begin or begin > display_buffer.range().end)
      |                                                              ~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc:98:143: warning: C++20 says that these are ambiguous, even though the second is reversed:
   98 |     auto first_it = std::lower_bound(lines.begin(), lines.end(), begin, [](const DisplayLine& l, const BufferCoord& c) { return l.range().end < c; });
      |                                                                                                                                 ~~~~~~~~~~~~~~^~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc:102:148: warning: C++20 says that these are ambiguous, even though the second is reversed:
  102 |     auto first_atom_it = std::find_if(first_it->begin(), first_it->end(), [&begin](const DisplayAtom& a) { return a.has_buffer_range() and a.end() > begin; });
      |                                                                                                                                            ~~~~~~~~^~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
highlighters.cc:105:135: warning: C++20 says that these are ambiguous, even though the second is reversed:
  105 |     auto last_it = std::lower_bound(first_it, lines.end(), end, [](const DisplayLine& l, const BufferCoord& c) { return l.range().end < c; });
      |                                                                                                                         ~~~~~~~~~~~~~~^~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
In file included from display_buffer.hh:7,
                 from highlighter.hh:6:
range.hh: In instantiation of 'bool Kakoune::operator==(const Range<BufferCoord>&, const Range<BufferCoord>&)':
hash_map.hh:223:71:   required from 'constexpr int Kakoune::HashMap<Key, Value, domain, Container, multi_key>::find_index(const KeyType&, size_t) const [with KeyType = Kakoune::Range<Kakoune::BufferCoord>; Key = Kakoune::Range<Kakoune::BufferCoord>; Value = std::vector<Kakoune::RegexHighlighter::Cache::RangeAndMatches, Kakoune::Allocator<Kakoune::RegexHighlighter::Cache::RangeAndMatches, Kakoune::MemoryDomain::Highlight> >; Kakoune::MemoryDomain domain = Kakoune::MemoryDomain::Highlight; Container = Kakoune::Vector; bool multi_key = false; size_t = long unsigned int]'
hash_map.hh:239:32:   required from 'constexpr Kakoune::HashMap<Key, Value, domain, Container, multi_key>::EffectiveValue& Kakoune::HashMap<Key, Value, domain, Container, multi_key>::operator[](KeyType&&) [with KeyType = Kakoune::Range<Kakoune::BufferCoord>&; Key = Kakoune::Range<Kakoune::BufferCoord>; Value = std::vector<Kakoune::RegexHighlighter::Cache::RangeAndMatches, Kakoune::Allocator<Kakoune::RegexHighlighter::Cache::RangeAndMatches, Kakoune::MemoryDomain::Highlight> >; Kakoune::MemoryDomain domain = Kakoune::MemoryDomain::Highlight; Container = Kakoune::Vector; bool multi_key = false; EffectiveValue = std::vector<Kakoune::RegexHighlighter::Cache::RangeAndMatches, Kakoune::Allocator<Kakoune::RegexHighlighter::Cache::RangeAndMatches, Kakoune::MemoryDomain::Highlight> >]'
highlighters.cc:402:53:   required from here
range.hh:15:26: warning: C++20 says that these are ambiguous, even though the second is reversed:
   15 |         return lhs.begin == rhs.begin and lhs.end == rhs.end;
      |                ~~~~~~~~~~^~~~~~~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
range.hh:15:51: warning: C++20 says that these are ambiguous, even though the second is reversed:
   15 |         return lhs.begin == rhs.begin and lhs.end == rhs.end;
      |                                           ~~~~~~~~^~~~~~~~~~
coord.hh:52:20: note: candidate 1: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]'
   52 |     constexpr bool operator== (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:52:20: note: candidate 2: 'constexpr bool Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator==(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
In file included from highlighters.cc:5:
changes.hh: In instantiation of 'auto Kakoune::update_range(ForwardChangesTracker&, Range&, AdvanceFunc&&) [with Range = std::tuple<InclusiveBufferRange, String>; AdvanceFunc = update_forward<std::vector<std::tuple<InclusiveBufferRange, String>, Allocator<std::tuple<InclusiveBufferRange, String>, Kakoune::MemoryDomain::Options> > >(ConstArrayView<Buffer::Change>, std::vector<std::tuple<InclusiveBufferRange, String>, Allocator<std::tuple<InclusiveBufferRange, String>, Kakoune::MemoryDomain::Options> >&)::<lambda(const BufferCoord&)>&]':
changes.hh:59:21:   required from 'void Kakoune::update_forward(ConstArrayView<Buffer::Change>, RangeContainer&) [with RangeContainer = std::vector<std::tuple<InclusiveBufferRange, String>, Allocator<std::tuple<InclusiveBufferRange, String>, Kakoune::MemoryDomain::Options> >; ConstArrayView<Buffer::Change> = ArrayView<const Buffer::Change>]'
changes.hh:98:27:   required from 'void Kakoune::update_ranges(Buffer&, size_t&, RangeContainer&&) [with RangeContainer = std::vector<std::tuple<InclusiveBufferRange, String>, Allocator<std::tuple<InclusiveBufferRange, String>, Kakoune::MemoryDomain::Options> >&; size_t = long unsigned int]'
highlighters.cc:1590:18:   required from here
changes.hh:39:14: warning: C++20 says that these are ambiguous, even though the second is reversed:
   39 |     if (last < BufferCoord{0,0})
      |         ~~~~~^~~~~~~~~~~~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
changes.hh: In instantiation of 'auto Kakoune::update_range(ForwardChangesTracker&, Range&, AdvanceFunc&&) [with Range = std::tuple<InclusiveBufferRange, String>; AdvanceFunc = update_backward<std::vector<std::tuple<InclusiveBufferRange, String>, Allocator<std::tuple<InclusiveBufferRange, String>, Kakoune::MemoryDomain::Options> > >(ConstArrayView<Buffer::Change>, std::vector<std::tuple<InclusiveBufferRange, String>, Allocator<std::tuple<InclusiveBufferRange, String>, Kakoune::MemoryDomain::Options> >&)::<lambda(const BufferCoord&)>&]':
changes.hh:81:21:   required from 'void Kakoune::update_backward(ConstArrayView<Buffer::Change>, RangeContainer&) [with RangeContainer = std::vector<std::tuple<InclusiveBufferRange, String>, Allocator<std::tuple<InclusiveBufferRange, String>, Kakoune::MemoryDomain::Options> >; ConstArrayView<Buffer::Change> = ArrayView<const Buffer::Change>]'
changes.hh:103:28:   required from 'void Kakoune::update_ranges(Buffer&, size_t&, RangeContainer&&) [with RangeContainer = std::vector<std::tuple<InclusiveBufferRange, String>, Allocator<std::tuple<InclusiveBufferRange, String>, Kakoune::MemoryDomain::Options> >&; size_t = long unsigned int]'
highlighters.cc:1590:18:   required from here
changes.hh:39:14: warning: C++20 says that these are ambiguous, even though the second is reversed:
   39 |     if (last < BufferCoord{0,0})
      |         ~~~~~^~~~~~~~~~~~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
changes.hh: In instantiation of 'Kakoune::update_forward<std::vector<std::tuple<InclusiveBufferRange, String>, Allocator<std::tuple<InclusiveBufferRange, String>, Kakoune::MemoryDomain::Options> > >(ConstArrayView<Buffer::Change>, std::vector<std::tuple<InclusiveBufferRange, String>, Allocator<std::tuple<InclusiveBufferRange, String>, Kakoune::MemoryDomain::Options> >&)::<lambda(auto:69&, const Kakoune::Buffer::Change&)> [with auto:69 = std::tuple<Kakoune::InclusiveBufferRange, Kakoune::String>]':
/usr/include/c++/13/bits/predefined_ops.h:196:23:   required from 'constexpr bool __gnu_cxx::__ops::_Iter_comp_val<_Compare>::operator()(_Iterator, _Value&) [with _Iterator = __gnu_cxx::__normal_iterator<std::tuple<Kakoune::InclusiveBufferRange, Kakoune::String>*, std::vector<std::tuple<Kakoune::InclusiveBufferRange, Kakoune::String>, Kakoune::Allocator<std::tuple<Kakoune::InclusiveBufferRange, Kakoune::String>, Kakoune::MemoryDomain::Options> > >; _Value = const Kakoune::Buffer::Change; _Compare = Kakoune::update_forward<std::vector<std::tuple<InclusiveBufferRange, String>, Allocator<std::tuple<InclusiveBufferRange, String>, Kakoune::MemoryDomain::Options> > >(ConstArrayView<Buffer::Change>, std::vector<std::tuple<InclusiveBufferRange, String>, Allocator<std::tuple<InclusiveBufferRange, String>, Kakoune::MemoryDomain::Options> >&)::<lambda(auto:69&, const Kakoune::Buffer::Change&)>]'
/usr/include/c++/13/bits/stl_algobase.h:1472:14:   required from 'constexpr _ForwardIterator std::__lower_bound(_ForwardIterator, _ForwardIterator, const _Tp&, _Compare) [with _ForwardIterator = __gnu_cxx::__normal_iterator<tuple<Kakoune::InclusiveBufferRange, Kakoune::String>*, vector<tuple<Kakoune::InclusiveBufferRange, Kakoune::String>, Kakoune::Allocator<tuple<Kakoune::InclusiveBufferRange, Kakoune::String>, Kakoune::MemoryDomain::Options> > >; _Tp = Kakoune::Buffer::Change; _Compare = __gnu_cxx::__ops::_Iter_comp_val<Kakoune::update_forward<std::vector<std::tuple<InclusiveBufferRange, String>, Allocator<std::tuple<InclusiveBufferRange, String>, Kakoune::MemoryDomain::Options> > >(ConstArrayView<Buffer::Change>, std::vector<std::tuple<InclusiveBufferRange, String>, Allocator<std::tuple<InclusiveBufferRange, String>, Kakoune::MemoryDomain::Options> >&)::<lambda(auto:69&, const Kakoune::Buffer::Change&)> >]'
/usr/include/c++/13/bits/stl_algo.h:2015:32:   required from 'constexpr _FIter std::lower_bound(_FIter, _FIter, const _Tp&, _Compare) [with _FIter = __gnu_cxx::__normal_iterator<tuple<Kakoune::InclusiveBufferRange, Kakoune::String>*, vector<tuple<Kakoune::InclusiveBufferRange, Kakoune::String>, Kakoune::Allocator<tuple<Kakoune::InclusiveBufferRange, Kakoune::String>, Kakoune::MemoryDomain::Options> > >; _Tp = Kakoune::Buffer::Change; _Compare = Kakoune::update_forward<std::vector<std::tuple<InclusiveBufferRange, String>, Allocator<std::tuple<InclusiveBufferRange, String>, Kakoune::MemoryDomain::Options> > >(ConstArrayView<Buffer::Change>, std::vector<std::tuple<InclusiveBufferRange, String>, Allocator<std::tuple<InclusiveBufferRange, String>, Kakoune::MemoryDomain::Options> >&)::<lambda(auto:69&, const Kakoune::Buffer::Change&)>]'
changes.hh:56:37:   required from 'void Kakoune::update_forward(ConstArrayView<Buffer::Change>, RangeContainer&) [with RangeContainer = std::vector<std::tuple<InclusiveBufferRange, String>, Allocator<std::tuple<InclusiveBufferRange, String>, Kakoune::MemoryDomain::Options> >; ConstArrayView<Buffer::Change> = ArrayView<const Buffer::Change>]'
changes.hh:98:27:   required from 'void Kakoune::update_ranges(Buffer&, size_t&, RangeContainer&&) [with RangeContainer = std::vector<std::tuple<InclusiveBufferRange, String>, Allocator<std::tuple<InclusiveBufferRange, String>, Kakoune::MemoryDomain::Options> >&; size_t = long unsigned int]'
highlighters.cc:1590:18:   required from here
changes.hh:57:109: warning: C++20 says that these are ambiguous, even though the second is reversed:
   57 |                                      [](auto& range, const Buffer::Change& change) { return get_last(range) < change.begin; });
      |                                                                                             ~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~
coord.hh:45:20: note: candidate 1: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (rewritten)
   45 |     constexpr auto operator<=> (EffectiveType other) const
      |                    ^~~~~~~~
coord.hh:45:20: note: candidate 2: 'constexpr auto Kakoune::LineAndColumn<EffectiveType, LineType, ColumnType>::operator<=>(EffectiveType) const [with EffectiveType = Kakoune::BufferCoord; LineType = Kakoune::LineCount; ColumnType = Kakoune::ByteCount]' (reversed)
*** WARNING *** there are active plugins, do not report this as a bug unless you can reproduce it without enabling any plugins.
Event                            | Plugins
PLUGIN_FINISH_UNIT               | annobin: Generate final annotations
PLUGIN_START_UNIT                | annobin: Generate global annotations
PLUGIN_ALL_PASSES_START          | annobin: Generate per-function annotations
PLUGIN_ALL_PASSES_END            | annobin: Register per-function end symbols
during IPA pass: modref
highlighters.cc: At top level:
highlighters.cc:2474:1: internal compiler error: tree code '<invalid tree code>' is not supported in LTO streams
 2474 | }
      | ^
Please submit a full bug report, with preprocessed source.
See <http://bugzilla.redhat.com/bugzilla> for instructions.
The bug is not reproducible, so it is likely a hardware or OS problem.
make: *** [Makefile:103: .highlighters.opt.o] Error 1
make: Leaving directory '/builddir/build/BUILD/kakoune-2022.10.31/src'
RPM build errors:
error: Bad exit status from /var/tmp/rpm-tmp.Twdlpb (%build)
    Bad exit status from /var/tmp/rpm-tmp.Twdlpb (%build)
Child return code was: 1
EXCEPTION: [Error()]
Traceback (most recent call last):
  File "/usr/lib/python3.10/site-packages/mockbuild/trace_decorator.py", line 93, in trace
    result = func(*args, **kw)
  File "/usr/lib/python3.10/site-packages/mockbuild/util.py", line 598, in do_with_status
    raise exception.Error("Command failed: \n # %s\n%s" % (command, output), child.returncode)
mockbuild.exception.Error: Command failed: 
 # bash --login -c /usr/bin/rpmbuild -bb --target riscv64 --nodeps /builddir/build/SPECS/kakoune.spec