completion: install completers to conventional locations

Installs the bash and zsh completers to the convential locations so they will
automatically be picked up without user intervention.  The zsh completer
on Debian is still installed to vendor-completions to match their policy.

bash: https://github.com/scop/bash-completion#faq
zsh: https://github.com/zsh-users/zsh/blob/57305cf245853b8b30895b41a90142dffab97e38/INSTALL#L254
Debian zsh: https://salsa.debian.org/debian/zsh/-/blob/5086b5356abcef8849dc8a09902b7c55f01db3c0/debian/README.Debian#L73

Makefile

@@ -1,293 +1,283 b''
 # If you want to change PREFIX, do not just edit it below. The changed
 # value wont get passed on to recursive make calls. You should instead
 # override the variable on the command like:
 #
 # % make PREFIX=/opt/ install
 
 export PREFIX=/usr/local
 
 # Default to Python 3.
 #
 # Windows ships Python 3 as `python.exe`, which may not be on PATH.  py.exe is.
 ifeq ($(OS),Windows_NT)
 PYTHON?=py -3
 else
 PYTHON?=python3
 endif
 
 PYOXIDIZER?=pyoxidizer
 
 $(eval HGROOT := $(shell pwd))
 HGPYTHONS ?= $(HGROOT)/build/pythons
 PURE=
 PYFILESCMD=find mercurial hgext doc -name '*.py'
 PYFILES:=$(shell $(PYFILESCMD))
 DOCFILES=mercurial/helptext/*.txt
 export LANGUAGE=C
 export LC_ALL=C
 TESTFLAGS ?= $(shell echo $$HGTESTFLAGS)
 OSXVERSIONFLAGS ?= $(shell echo $$OSXVERSIONFLAGS)
 CARGO = cargo
 
 # Set this to e.g. "mingw32" to use a non-default compiler.
 COMPILER=
 
 COMPILERFLAG_tmp_ =
 COMPILERFLAG_tmp_${COMPILER} ?= -c $(COMPILER)
 COMPILERFLAG=${COMPILERFLAG_tmp_${COMPILER}}
 
 help:
 	@echo 'Commonly used make targets:'
 	@echo '  all          - build program and documentation'
 	@echo '  install      - install program and man pages to $$PREFIX ($(PREFIX))'
 	@echo '  install-home - install with setup.py install --home=$$HOME ($(HOME))'
 	@echo '  local        - build for inplace usage'
 	@echo '  tests        - run all tests in the automatic test suite'
 	@echo '  test-foo     - run only specified tests (e.g. test-merge1.t)'
 	@echo '  dist         - run all tests and create a source tarball in dist/'
 	@echo '  clean        - remove files created by other targets'
 	@echo '                 (except installed files or dist source tarball)'
 	@echo '  update-pot   - update i18n/hg.pot'
 	@echo
 	@echo 'Example for a system-wide installation under /usr/local:'
 	@echo '  make all && su -c "make install" && hg version'
 	@echo
 	@echo 'Example for a local installation (usable in this directory):'
 	@echo '  make local && ./hg version'
 
 all: build doc
 
 local:
 	$(PYTHON) setup.py $(PURE) \
 	  build_py -c -d . \
 	  build_ext $(COMPILERFLAG) -i \
 	  build_hgexe $(COMPILERFLAG) -i \
 	  build_mo
 	env HGRCPATH= $(PYTHON) hg version
 
 build:
 	$(PYTHON) setup.py $(PURE) build $(COMPILERFLAG)
 
 build-chg:
 	make -C contrib/chg
 
 build-rhg:
 	(cd rust/rhg; cargo build --release)
 
 wheel:
 	FORCE_SETUPTOOLS=1 $(PYTHON) setup.py $(PURE) bdist_wheel $(COMPILERFLAG)
 
 doc:
 	$(MAKE) -C doc
 
 cleanbutpackages:
 	rm -f hg.exe
 	-$(PYTHON) setup.py clean --all # ignore errors from this command
 	find contrib doc hgext hgext3rd i18n mercurial tests hgdemandimport \
 		\( -name '*.py[cdo]' -o -name '*.so' \) -exec rm -f '{}' ';'
 	rm -f MANIFEST MANIFEST.in hgext/__index__.py tests/*.err
 	rm -f mercurial/__modulepolicy__.py
 	if test -d .hg; then rm -f mercurial/__version__.py; fi
 	rm -rf build mercurial/locale
 	$(MAKE) -C doc clean
 	$(MAKE) -C contrib/chg distclean
 	rm -rf rust/target
 	rm -f mercurial/rustext.so
 
 clean: cleanbutpackages
 	rm -rf packages
 
 install: install-bin install-doc
 
 install-bin: build
 	$(PYTHON) setup.py $(PURE) install --root="$(DESTDIR)/" --prefix="$(PREFIX)" --force
 
 install-chg: build-chg
 	make -C contrib/chg install PREFIX="$(PREFIX)"
 
 install-doc: doc
 	cd doc && $(MAKE) $(MFLAGS) install
 
 install-home: install-home-bin install-home-doc
 
 install-home-bin: build
 	$(PYTHON) setup.py $(PURE) install --home="$(HOME)" --prefix="" --force
 
 install-home-doc: doc
 	cd doc && $(MAKE) $(MFLAGS) PREFIX="$(HOME)" install
 
 install-rhg: build-rhg
 	install -m 755 rust/target/release/rhg "$(PREFIX)"/bin/
 
 MANIFEST-doc:
 	$(MAKE) -C doc MANIFEST
 
 MANIFEST.in: MANIFEST-doc
 	hg manifest | sed -e 's/^/include /' > MANIFEST.in
 	echo include mercurial/__version__.py >> MANIFEST.in
 	sed -e 's/^/include /' < doc/MANIFEST >> MANIFEST.in
 
 dist:	tests dist-notests
 
 dist-notests:	doc MANIFEST.in
 	TAR_OPTIONS="--owner=root --group=root --mode=u+w,go-w,a+rX-s" $(PYTHON) setup.py -q sdist
 
 check: tests
 
 tests:
         # Run Rust tests if cargo is installed
 	if command -v $(CARGO) >/dev/null 2>&1; then \
 		$(MAKE) rust-tests; \
 	fi
 	cd tests && $(PYTHON) run-tests.py $(TESTFLAGS)
 
 test-%:
 	cd tests && $(PYTHON) run-tests.py $(TESTFLAGS) $@
 
 testpy-%:
 	@echo Looking for Python $* in $(HGPYTHONS)
 	[ -e $(HGPYTHONS)/$*/bin/python ] || ( \
 	cd $$(mktemp --directory --tmpdir) && \
         $(MAKE) -f $(HGROOT)/contrib/Makefile.python PYTHONVER=$* PREFIX=$(HGPYTHONS)/$* python )
 	cd tests && $(HGPYTHONS)/$*/bin/python run-tests.py $(TESTFLAGS)
 
 rust-tests:
 	cd $(HGROOT)/rust/hg-cpython \
 		&& $(CARGO) test --quiet --all --features "$(HG_RUST_FEATURES)"
 
 check-code:
 	hg manifest | xargs python contrib/check-code.py
 
 format-c:
 	clang-format --style file -i \
 	  `hg files 'set:(**.c or **.cc or **.h) and not "listfile:contrib/clang-format-ignorelist"'`
 
 update-pot: i18n/hg.pot
 
 i18n/hg.pot: $(PYFILES) $(DOCFILES) i18n/posplit i18n/hggettext
 	$(PYTHON) i18n/hggettext mercurial/commands.py \
 	  hgext/*.py hgext/*/__init__.py \
 	  mercurial/fileset.py mercurial/revset.py \
 	  mercurial/templatefilters.py \
 	  mercurial/templatefuncs.py \
 	  mercurial/templatekw.py \
 	  mercurial/filemerge.py \
 	  mercurial/hgweb/webcommands.py \
 	  mercurial/util.py \
 	  $(DOCFILES) > i18n/hg.pot.tmp
         # All strings marked for translation in Mercurial contain
         # ASCII characters only. But some files contain string
         # literals like this '\037\213'. xgettext thinks it has to
         # parse them even though they are not marked for translation.
         # Extracting with an explicit encoding of ISO-8859-1 will make
         # xgettext "parse" and ignore them.
 	$(PYFILESCMD) | xargs \
 	  xgettext --package-name "Mercurial" \
 	  --msgid-bugs-address "<[e-mail]>" \
 	  --copyright-holder "Olivia Mackall <[e-mail]> and others" \
 	  --from-code ISO-8859-1 --join --sort-by-file --add-comments=i18n: \
 	  -d hg -p i18n -o hg.pot.tmp
 	$(PYTHON) i18n/posplit i18n/hg.pot.tmp
         # The target file is not created before the last step. So it never is in
         # an intermediate state.
 	mv -f i18n/hg.pot.tmp i18n/hg.pot
 
 %.po: i18n/hg.pot
         # work on a temporary copy for never having a half completed target
 	cp $@ $@.tmp
 	msgmerge --no-location --update $@.tmp $^
 	mv -f $@.tmp $@
 
 # Packaging targets
 
 packaging_targets := \
   rhel7 \
   rhel8 \
   deb \
   docker-rhel7 \
   docker-rhel8 \
   docker-debian-bullseye \
   docker-debian-buster \
   docker-debian-stretch \
   docker-fedora \
   docker-ubuntu-xenial \
   docker-ubuntu-xenial-ppa \
   docker-ubuntu-bionic \
   docker-ubuntu-bionic-ppa \
   docker-ubuntu-focal \
   docker-ubuntu-focal-ppa \
   fedora \
   linux-wheels \
   linux-wheels-x86_64 \
   linux-wheels-i686 \
   ppa
 
 # Forward packaging targets for convenience.
 $(packaging_targets):
 	$(MAKE) -C contrib/packaging $@
 
 osx:
 	rm -rf build/mercurial
 	/usr/bin/python2.7 setup.py install --optimize=1 \
 	  --root=build/mercurial/ --prefix=/usr/local/ \
 	  --install-lib=/Library/Python/2.7/site-packages/
 	make -C doc all install DESTDIR="$(PWD)/build/mercurial/"
         # Place a bogon .DS_Store file in the target dir so we can be
         # sure it doesn't get included in the final package.
 	touch build/mercurial/.DS_Store
-        # install zsh completions - this location appears to be
-        # searched by default as of macOS Sierra.
-	install -d build/mercurial/usr/local/share/zsh/site-functions/
-	install -m 0644 contrib/zsh_completion build/mercurial/usr/local/share/zsh/site-functions/_hg
-        # install bash completions - there doesn't appear to be a
-        # place that's searched by default for bash, so we'll follow
-        # the lead of Apple's git install and just put it in a
-        # location of our own.
-	install -d build/mercurial/usr/local/hg/contrib/
-	install -m 0644 contrib/bash_completion build/mercurial/usr/local/hg/contrib/hg-completion.bash
 	make -C contrib/chg \
 	  HGPATH=/usr/local/bin/hg \
 	  PYTHON=/usr/bin/python2.7 \
 	  DESTDIR=../../build/mercurial \
 	  PREFIX=/usr/local \
 	  clean install
 	mkdir -p $${OUTPUTDIR:-dist}
 	HGVER=$$(python contrib/genosxversion.py $(OSXVERSIONFLAGS) build/mercurial/Library/Python/2.7/site-packages/mercurial/__version__.py) && \
 	OSXVER=$$(sw_vers -productVersion | cut -d. -f1,2) && \
 	pkgbuild --filter \\.DS_Store --root build/mercurial/ \
 	  --identifier org.mercurial-scm.mercurial \
 	  --version "$${HGVER}" \
 	  build/mercurial.pkg && \
 	productbuild --distribution contrib/packaging/macosx/distribution.xml \
 	  --package-path build/ \
 	  --version "$${HGVER}" \
 	  --resources contrib/packaging/macosx/ \
 	  "$${OUTPUTDIR:-dist/}"/Mercurial-"$${HGVER}"-macosx"$${OSXVER}".pkg
 
 pyoxidizer:
 	$(PYOXIDIZER) build --path ./rust/hgcli --release
 
 
 PYOX_DIR=build/pyoxidizer/x86_64-pc-windows-msvc/release/app
 
 # a temporary target to setup all we need for run-tests.py --pyoxidizer
 # (should go away as the run-tests implementation improves
 pyoxidizer-windows-tests: pyoxidizer
 	rm -rf $(PYOX_DIR)/templates
 	cp -ar $(PYOX_DIR)/lib/mercurial/templates $(PYOX_DIR)/templates
 	rm -rf $(PYOX_DIR)/helptext
 	cp -ar $(PYOX_DIR)/lib/mercurial/helptext $(PYOX_DIR)/helptext
 	rm -rf $(PYOX_DIR)/defaultrc
 	cp -ar $(PYOX_DIR)/lib/mercurial/defaultrc $(PYOX_DIR)/defaultrc
 	rm -rf $(PYOX_DIR)/contrib
 	cp -ar contrib $(PYOX_DIR)/contrib
 	rm -rf $(PYOX_DIR)/doc
 	cp -ar doc $(PYOX_DIR)/doc
 
 
 .PHONY: help all local build doc cleanbutpackages clean install install-bin \
 	install-doc install-home install-home-bin install-home-doc \
 	dist dist-notests check tests rust-tests check-code format-c \
 	update-pot pyoxidizer pyoxidizer-windows-tests \
 	$(packaging_targets) \
 	osx

contrib/packaging/debian/rules

@@ -1,103 +1,101 b''
 #!/usr/bin/make -f
 # Uncomment this to turn on verbose mode.
 # export DH_VERBOSE=1
 
 # By default we build a .deb where the native components are built with the
 # current "default" version of py3 on the build machine. If you wish to build a
 # .deb that has native components built for multiple versions of py3:
 #
 #   1. install python3.x and python3.x-dev for each version you want
 #   2. set DEB_HG_MULTI_VERSION=1 or DEB_HG_PYTHON_VERSIONS in your environment
 #      (if both are set, DEB_HG_PYTHON_VERSIONS has precedence)
 #
 # If you choose `DEB_HG_MULTI_VERSION=1`, it will build for every "supported"
 # version of py3 that's installed on the build machine. This may not be equal to
 # the actual versions that are installed, see the comment above where we set
 # DEB_HG_PYTHON_VERSIONS below. If you choose to set `DEB_HG_PYTHON_VERSIONS`
 # yourself, set it to a space-separated string of python version numbers, like:
 #   DEB_HG_PYTHON_VERSIONS="3.7 3.8" make deb
 DEB_HG_MULTI_VERSION?=0
 
 # Set to 1 to make /usr/bin/hg a symlink to chg, and move hg to
 # /usr/lib/mercurial/hg.
 DEB_HG_CHG_BY_DEFAULT?=0
 
 CPUS=$(shell cat /proc/cpuinfo | grep -E ^processor | wc -l)
 
 # By default, only build for the version of python3 that the system considers
 # the 'default' (which should be the one invoked by just running 'python3'
 # without a minor version). If DEB_HG_PYTHON_VERSIONS is set, this is ignored.
 ifeq ($(DEB_HG_MULTI_VERSION), 1)
 	# If we're building for multiple versions, use all of the "supported" versions
 	# on the build machine. Note: the mechanism in use here (`py3versions`) is the
 	# recommended one, but it relies on a file written by the python3-minimal
 	# package, and this file is not dynamic and does not account for manual
 	# installations, just the ones that would be installed by `python3-all`. This
 	# includes the `-i` flag, which claims it's to list all "installed" versions,
 	# but it doesn't. This was quite confusing, hence this tale of woe. :)
 	DEB_HG_PYTHON_VERSIONS?=$(shell py3versions -vs)
 else
 	# If we're building for only one version, identify the "default" version on
 	# the build machine and use that when building; this is just so that we don't
 	# have to duplicate the rules below for multi-version vs. single-version. The
 	# shebang line will still be /usr/bin/python3 (no minor version).
 	DEB_HG_PYTHON_VERSIONS?=$(shell py3versions -vd)
 endif
 
 ifeq ($(DEB_HG_CHG_BY_DEFAULT), 1)
 	# Important: the "real" hg must have a 'basename' of 'hg'. Otherwise, hg
 	# behaves differently when setting $HG and breaks aliases that use that.
 	export HGPATH=/usr/lib/mercurial/hg
 endif
 
 export HGPYTHON3=1
 export PYTHON=python3
 
 %:
 	dh $@ --with python3
 
 # Note: testing can be disabled using the standard `DEB_BUILD_OPTIONS=nocheck`
 override_dh_auto_test:
 	http_proxy='' dh_auto_test -- TESTFLAGS="-j$(CPUS)"
 
 override_dh_python3:
 	dh_python3 --shebang=/usr/bin/python3
 
 override_dh_auto_clean:
 	$(MAKE) cleanbutpackages
 	$(MAKE) -C contrib/chg clean
 
 override_dh_auto_build:
 	$(MAKE) all
 	$(MAKE) -C contrib/chg all
 
 # Build the native extensions for a specfic python3 version (which must be
 # installed on the build machine).
 install-python%:
 	python$* setup.py install --root "$(CURDIR)"/debian/mercurial --install-layout=deb
 
 # Build the final package. This rule has a dependencies section that causes the
 # native extensions to be compiled for every version of python3 listed in
 # DEB_HG_PYTHON_VERSIONS.
 override_dh_auto_install: $(DEB_HG_PYTHON_VERSIONS:%=install-python%)
 	# chg
 	make -C contrib/chg \
 		DESTDIR="$(CURDIR)"/debian/mercurial \
 		PREFIX=/usr \
 		install
 	make install-doc PREFIX="$(CURDIR)"/debian/mercurial/usr
 	cp contrib/hg-ssh "$(CURDIR)"/debian/mercurial/usr/bin
 	mkdir -p "$(CURDIR)"/debian/mercurial/usr/share/mercurial
 	cp contrib/hgk "$(CURDIR)"/debian/mercurial/usr/share/mercurial
 	mkdir -p "$(CURDIR)"/debian/mercurial/etc/mercurial/hgrc.d/
 	cp contrib/packaging/debian/*.rc "$(CURDIR)"/debian/mercurial/etc/mercurial/hgrc.d/
 	# completions
-	mkdir -p "$(CURDIR)"/debian/mercurial/usr/share/bash-completion/completions
-	cp contrib/bash_completion "$(CURDIR)"/debian/mercurial/usr/share/bash-completion/completions/hg
 	mkdir -p "$(CURDIR)"/debian/mercurial/usr/share/zsh/vendor-completions
-	cp contrib/zsh_completion "$(CURDIR)"/debian/mercurial/usr/share/zsh/vendor-completions/_hg
+	mv "$(CURDIR)"/debian/mercurial/usr/share/zsh/site-functions/_hg "$(CURDIR)"/debian/mercurial/usr/share/zsh/vendor-completions/_hg
 	if [ "$(DEB_HG_CHG_BY_DEFAULT)" -eq 1 ]; then \
 		mkdir -p "$(CURDIR)"/debian/mercurial/usr/lib/mercurial; \
 		mv "$(CURDIR)"/debian/mercurial/usr/bin/hg "$(CURDIR)"/debian/mercurial/usr/lib/mercurial/hg; \
 		ln -s chg "$(CURDIR)"/debian/mercurial/usr/bin/hg; \
 	fi

contrib/packaging/hgpackaging/pyoxidizer.py

@@ -1,175 +1,173 b''
 # pyoxidizer.py - Packaging support for PyOxidizer
 #
 # Copyright 2020 Gregory Szorc <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 # no-check-code because Python 3 native.
 
 import os
 import pathlib
 import shutil
 import subprocess
 import sys
 import typing
 
 from .downloads import download_entry
 from .util import (
     extract_zip_to_directory,
     process_install_rules,
     find_vc_runtime_dll,
 )
 
 
 STAGING_RULES_WINDOWS = [
-    ('contrib/bash_completion', 'contrib/'),
     ('contrib/hgk', 'contrib/hgk.tcl'),
     ('contrib/hgweb.fcgi', 'contrib/'),
     ('contrib/hgweb.wsgi', 'contrib/'),
     ('contrib/logo-droplets.svg', 'contrib/'),
     ('contrib/mercurial.el', 'contrib/'),
     ('contrib/mq.el', 'contrib/'),
     ('contrib/tcsh_completion', 'contrib/'),
     ('contrib/tcsh_completion_build.sh', 'contrib/'),
     ('contrib/vim/*', 'contrib/vim/'),
     ('contrib/win32/postinstall.txt', 'ReleaseNotes.txt'),
     ('contrib/win32/ReadMe.html', 'ReadMe.html'),
     ('contrib/xml.rnc', 'contrib/'),
-    ('contrib/zsh_completion', 'contrib/'),
     ('doc/*.html', 'doc/'),
     ('doc/style.css', 'doc/'),
     ('COPYING', 'Copying.txt'),
 ]
 
 STAGING_RULES_APP = [
     ('lib/mercurial/helptext/**/*.txt', 'helptext/'),
     ('lib/mercurial/defaultrc/*.rc', 'defaultrc/'),
     ('lib/mercurial/locale/**/*', 'locale/'),
     ('lib/mercurial/templates/**/*', 'templates/'),
 ]
 
 STAGING_EXCLUDES_WINDOWS = [
     "doc/hg-ssh.8.html",
 ]
 
 
 def build_docs_html(source_dir: pathlib.Path):
     """Ensures HTML documentation is built.
 
     This will fail if docutils isn't available.
 
     (The HTML docs aren't built as part of `pip install` so we need to build them
     out of band.)
     """
     subprocess.run(
         [sys.executable, str(source_dir / "setup.py"), "build_doc", "--html"],
         cwd=str(source_dir),
         check=True,
     )
 
 
 def run_pyoxidizer(
     source_dir: pathlib.Path,
     build_dir: pathlib.Path,
     target_triple: str,
     build_vars: typing.Optional[typing.Dict[str, str]] = None,
     target: typing.Optional[str] = None,
 ) -> pathlib.Path:
     """Run `pyoxidizer` in an environment with access to build dependencies.
 
     Returns the output directory that pyoxidizer would have used for build
     artifacts. Actual build artifacts are likely in a sub-directory with the
     name of the pyoxidizer build target that was built.
     """
     build_vars = build_vars or {}
 
     # We need to make gettext binaries available for compiling i18n files.
     gettext_pkg, gettext_entry = download_entry('gettext', build_dir)
     gettext_dep_pkg = download_entry('gettext-dep', build_dir)[0]
 
     gettext_root = build_dir / ('gettext-win-%s' % gettext_entry['version'])
 
     if not gettext_root.exists():
         extract_zip_to_directory(gettext_pkg, gettext_root)
         extract_zip_to_directory(gettext_dep_pkg, gettext_root)
 
     env = dict(os.environ)
     env["PATH"] = "%s%s%s" % (
         env["PATH"],
         os.pathsep,
         str(gettext_root / "bin"),
     )
 
     args = [
         "pyoxidizer",
         "build",
         "--path",
         str(source_dir / "rust" / "hgcli"),
         "--release",
         "--target-triple",
         target_triple,
     ]
 
     for k, v in sorted(build_vars.items()):
         args.extend(["--var", k, v])
 
     if target:
         args.append(target)
 
     subprocess.run(args, env=env, check=True)
 
     return source_dir / "build" / "pyoxidizer" / target_triple / "release"
 
 
 def create_pyoxidizer_install_layout(
     source_dir: pathlib.Path,
     build_dir: pathlib.Path,
     out_dir: pathlib.Path,
     target_triple: str,
 ):
     """Build Mercurial with PyOxidizer and copy additional files into place.
 
     After successful completion, ``out_dir`` contains files constituting a
     Mercurial install.
     """
 
     run_pyoxidizer(source_dir, build_dir, target_triple)
 
     build_dir = (
         source_dir / "build" / "pyoxidizer" / target_triple / "release" / "app"
     )
 
     if out_dir.exists():
         print("purging %s" % out_dir)
         shutil.rmtree(out_dir)
 
     # Now assemble all the files from PyOxidizer into the staging directory.
     shutil.copytree(build_dir, out_dir)
 
     # Move some of those files around. We can get rid of this once Mercurial
     # is taught to use the importlib APIs for reading resources.
     process_install_rules(STAGING_RULES_APP, build_dir, out_dir)
 
     build_docs_html(source_dir)
 
     if "windows" in target_triple:
         process_install_rules(STAGING_RULES_WINDOWS, source_dir, out_dir)
 
         # Write out a default editor.rc file to configure notepad as the
         # default editor.
         os.makedirs(out_dir / "defaultrc", exist_ok=True)
         with (out_dir / "defaultrc" / "editor.rc").open(
             "w", encoding="utf-8"
         ) as fh:
             fh.write("[ui]\neditor = notepad\n")
 
         for f in STAGING_EXCLUDES_WINDOWS:
             p = out_dir / f
             if p.exists():
                 print("removing %s" % p)
                 p.unlink()
 
         # Add vcruntimeXXX.dll next to executable.
         vc_runtime_dll = find_vc_runtime_dll(x64="x86_64" in target_triple)
         shutil.copy(vc_runtime_dll, out_dir / vc_runtime_dll.name)

contrib/packaging/mercurial.spec

@@ -1,174 +1,167 b''
 %global emacs_lispdir %{_datadir}/emacs/site-lisp
 
 %define withpython %{nil}
 
 %global pythonexe python3
 %global pythondocutils python3-docutils
 
 %if "%{?withpython}"
 
 %global pythonver %{withpython}
 %global pythonname Python-%{withpython}
 %global docutilsname docutils-0.14
 %global docutilsmd5 c53768d63db3873b7d452833553469de
 %global pythonhg python-hg
 %global hgpyprefix /opt/%{pythonhg}
 # byte compilation will fail on some some Python /test/ files
 %global _python_bytecompile_errors_terminate_build 0
 
 %else
 
 %global pythonver %(%{pythonexe} -c 'import sys;print(".".join(map(str, sys.version_info[:2])))')
 
 %endif
 
 Summary: A fast, lightweight Source Control Management system
 Name: mercurial
 Version: snapshot
 Release: 0
 License: GPLv2+
 Prefix: /
 Group: Development/Tools
 URL: https://mercurial-scm.org/
 Source0: %{name}-%{version}-%{release}.tar.gz
 %if "%{?withpython}"
 Source1: %{pythonname}.tgz
 Source2: %{docutilsname}.tar.gz
 %endif
 BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-root
 
 BuildRequires: make, gcc, gettext
 %if "%{?withpython}"
 BuildRequires: readline-devel, openssl-devel, ncurses-devel, zlib-devel, bzip2-devel
 %else
 BuildRequires: %{pythonexe} >= %{pythonver}, %{pythonexe}-devel, %{pythondocutils}
 Requires: %{pythonexe} >= %{pythonver}
 %endif
 # The hgk extension uses the wish tcl interpreter, but we don't enforce it
 #Requires: tk
 
 %description
 Mercurial is a fast, lightweight source control management system designed
 for efficient handling of very large distributed projects.
 
 %prep
 
 %if "%{?withpython}"
 %setup -q -n mercurial-%{version}-%{release} -a1 -a2
 # despite the comments in cgi.py, we do this to prevent rpmdeps from picking /usr/local/bin/python up
 sed -i '1c#! /usr/bin/env %{pythonexe}' %{pythonname}/Lib/cgi.py
 %else
 %setup -q -n mercurial-%{version}-%{release}
 %endif
 
 %build
 
 export HGPYTHON3=1
 
 %if "%{?withpython}"
 
 PYPATH=$PWD/%{pythonname}
 cd $PYPATH
 ./configure --prefix=%{hgpyprefix}
 make all %{?_smp_mflags}
 cd -
 
 cd %{docutilsname}
 LD_LIBRARY_PATH=$PYPATH $PYPATH/python setup.py build
 cd -
 
 # verify Python environment
 LD_LIBRARY_PATH=$PYPATH PYTHONPATH=$PWD/%{docutilsname} $PYPATH/python -c 'import sys, zlib, bz2, ssl, curses, readline'
 
 # set environment for make
 export PATH=$PYPATH:$PATH
 export LD_LIBRARY_PATH=$PYPATH
 export CFLAGS="-L $PYPATH"
 export PYTHONPATH=$PWD/%{docutilsname}
 
 %endif
 
 make all PYTHON=%{pythonexe}
 make -C contrib/chg
 
 sed -i -e '1s|#!/usr/bin/env python$|#!/usr/bin/env %{pythonexe}|' contrib/hg-ssh
 
 %install
 rm -rf $RPM_BUILD_ROOT
 
 export HGPYTHON3=1
 
 %if "%{?withpython}"
 
 PYPATH=$PWD/%{pythonname}
 cd $PYPATH
 make install DESTDIR=$RPM_BUILD_ROOT
 # these .a are not necessary and they are readonly and strip fails - kill them!
 rm -f %{buildroot}%{hgpyprefix}/lib/{,python2.*/config}/libpython2.*.a
 cd -
 
 cd %{docutilsname}
 LD_LIBRARY_PATH=$PYPATH $PYPATH/python setup.py install --root="$RPM_BUILD_ROOT"
 cd -
 
 PATH=$PYPATH:$PATH LD_LIBRARY_PATH=$PYPATH make install PYTHON=%{pythonexe} DESTDIR=$RPM_BUILD_ROOT PREFIX=%{hgpyprefix} MANDIR=%{_mandir} PURE="--rust"
 mkdir -p $RPM_BUILD_ROOT%{_bindir}
 ( cd $RPM_BUILD_ROOT%{_bindir}/ && ln -s ../..%{hgpyprefix}/bin/hg . )
 ( cd $RPM_BUILD_ROOT%{_bindir}/ && ln -s ../..%{hgpyprefix}/bin/python2.? %{pythonhg} )
 
 %else
 
 make install PYTHON=%{pythonexe} DESTDIR=$RPM_BUILD_ROOT PREFIX=%{_prefix} MANDIR=%{_mandir} PURE="--rust"
 
 %endif
 
 install -m 755 contrib/chg/chg $RPM_BUILD_ROOT%{_bindir}/
 install -m 755 contrib/hgk $RPM_BUILD_ROOT%{_bindir}/
 install -m 755 contrib/hg-ssh $RPM_BUILD_ROOT%{_bindir}/
 
-bash_completion_dir=$RPM_BUILD_ROOT%{_sysconfdir}/bash_completion.d
-mkdir -p $bash_completion_dir
-install -m 644 contrib/bash_completion $bash_completion_dir/mercurial.sh
-
-zsh_completion_dir=$RPM_BUILD_ROOT%{_datadir}/zsh/site-functions
-mkdir -p $zsh_completion_dir
-install -m 644 contrib/zsh_completion $zsh_completion_dir/_mercurial
-
 mkdir -p $RPM_BUILD_ROOT%{emacs_lispdir}
 install -m 644 contrib/mercurial.el $RPM_BUILD_ROOT%{emacs_lispdir}/
 install -m 644 contrib/mq.el $RPM_BUILD_ROOT%{emacs_lispdir}/
 
 mkdir -p $RPM_BUILD_ROOT/%{_sysconfdir}/mercurial/hgrc.d
 
 %clean
 rm -rf $RPM_BUILD_ROOT
 
 %files
 %defattr(-,root,root,-)
 %doc CONTRIBUTORS COPYING doc/README doc/hg*.txt doc/hg*.html *.cgi contrib/*.fcgi contrib/*.wsgi
 %doc %attr(644,root,root) %{_mandir}/man?/hg*
 %doc %attr(644,root,root) contrib/*.svg
+%dir %{_datadir}/bash-completion/
+%dir %{_datadir}/bash-completion/completions
+%{_datadir}/bash-completion/completions/hg
 %dir %{_datadir}/zsh/
 %dir %{_datadir}/zsh/site-functions/
-%{_datadir}/zsh/site-functions/_mercurial
+%{_datadir}/zsh/site-functions/_hg
 %dir %{_datadir}/emacs/site-lisp/
 %{_datadir}/emacs/site-lisp/mercurial.el
 %{_datadir}/emacs/site-lisp/mq.el
 %{_bindir}/hg
 %{_bindir}/chg
 %{_bindir}/hgk
 %{_bindir}/hg-ssh
-%dir %{_sysconfdir}/bash_completion.d/
-%config(noreplace) %{_sysconfdir}/bash_completion.d/mercurial.sh
 %dir %{_sysconfdir}/mercurial
 %dir %{_sysconfdir}/mercurial/hgrc.d
 %if "%{?withpython}"
 %{_bindir}/%{pythonhg}
 %{hgpyprefix}
 %else
 %{_libdir}/python%{pythonver}/site-packages/%{name}-*-py%{pythonver}.egg-info
 %{_libdir}/python%{pythonver}/site-packages/%{name}
 %{_libdir}/python%{pythonver}/site-packages/hgext
 %{_libdir}/python%{pythonver}/site-packages/hgext3rd
 %{_libdir}/python%{pythonver}/site-packages/hgdemandimport
 %endif

setup.py

@@ -1,1744 +1,1776 b''
 #
 # This is the mercurial setup script.
 #
 # 'python setup.py install', or
 # 'python setup.py --help' for more options
 import os
 
 # Mercurial can't work on 3.6.0 or 3.6.1 due to a bug in % formatting
 # in bytestrings.
 supportedpy = ','.join(
     [
         '>=3.6.2',
     ]
 )
 
 import sys, platform
 import sysconfig
 
 
 def sysstr(s):
     return s.decode('latin-1')
 
 
 import ssl
 
 # ssl.HAS_TLSv1* are preferred to check support but they were added in Python
 # 3.7. Prior to CPython commit 6e8cda91d92da72800d891b2fc2073ecbc134d98
 # (backported to the 3.7 branch), ssl.PROTOCOL_TLSv1_1 / ssl.PROTOCOL_TLSv1_2
 # were defined only if compiled against a OpenSSL version with TLS 1.1 / 1.2
 # support. At the mentioned commit, they were unconditionally defined.
 _notset = object()
 has_tlsv1_1 = getattr(ssl, 'HAS_TLSv1_1', _notset)
 if has_tlsv1_1 is _notset:
     has_tlsv1_1 = getattr(ssl, 'PROTOCOL_TLSv1_1', _notset) is not _notset
 has_tlsv1_2 = getattr(ssl, 'HAS_TLSv1_2', _notset)
 if has_tlsv1_2 is _notset:
     has_tlsv1_2 = getattr(ssl, 'PROTOCOL_TLSv1_2', _notset) is not _notset
 if not (has_tlsv1_1 or has_tlsv1_2):
     error = """
 The `ssl` module does not advertise support for TLS 1.1 or TLS 1.2.
 Please make sure that your Python installation was compiled against an OpenSSL
 version enabling these features (likely this requires the OpenSSL version to
 be at least 1.0.1).
 """
     print(error, file=sys.stderr)
     sys.exit(1)
 
 DYLIB_SUFFIX = sysconfig.get_config_vars()['EXT_SUFFIX']
 
 # Solaris Python packaging brain damage
 try:
     import hashlib
 
     sha = hashlib.sha1()
 except ImportError:
     try:
         import sha
 
         sha.sha  # silence unused import warning
     except ImportError:
         raise SystemExit(
             "Couldn't import standard hashlib (incomplete Python install)."
         )
 
 try:
     import zlib
 
     zlib.compressobj  # silence unused import warning
 except ImportError:
     raise SystemExit(
         "Couldn't import standard zlib (incomplete Python install)."
     )
 
 # The base IronPython distribution (as of 2.7.1) doesn't support bz2
 isironpython = False
 try:
     isironpython = (
         platform.python_implementation().lower().find("ironpython") != -1
     )
 except AttributeError:
     pass
 
 if isironpython:
     sys.stderr.write("warning: IronPython detected (no bz2 support)\n")
 else:
     try:
         import bz2
 
         bz2.BZ2Compressor  # silence unused import warning
     except ImportError:
         raise SystemExit(
             "Couldn't import standard bz2 (incomplete Python install)."
         )
 
 ispypy = "PyPy" in sys.version
 
 import ctypes
 import errno
 import stat, subprocess, time
 import re
 import shutil
 import tempfile
 
 # We have issues with setuptools on some platforms and builders. Until
 # those are resolved, setuptools is opt-in except for platforms where
 # we don't have issues.
 issetuptools = os.name == 'nt' or 'FORCE_SETUPTOOLS' in os.environ
 if issetuptools:
     from setuptools import setup
 else:
     from distutils.core import setup
 from distutils.ccompiler import new_compiler
 from distutils.core import Command, Extension
 from distutils.dist import Distribution
 from distutils.command.build import build
 from distutils.command.build_ext import build_ext
 from distutils.command.build_py import build_py
 from distutils.command.build_scripts import build_scripts
 from distutils.command.install import install
 from distutils.command.install_lib import install_lib
 from distutils.command.install_scripts import install_scripts
 from distutils import log
 from distutils.spawn import spawn, find_executable
 from distutils import file_util
 from distutils.errors import (
     CCompilerError,
     DistutilsError,
     DistutilsExecError,
 )
 from distutils.sysconfig import get_python_inc, get_config_var
 from distutils.version import StrictVersion
 
 # Explain to distutils.StrictVersion how our release candidates are versioned
 StrictVersion.version_re = re.compile(r'^(\d+)\.(\d+)(\.(\d+))?-?(rc(\d+))?$')
 
 
 def write_if_changed(path, content):
     """Write content to a file iff the content hasn't changed."""
     if os.path.exists(path):
         with open(path, 'rb') as fh:
             current = fh.read()
     else:
         current = b''
 
     if current != content:
         with open(path, 'wb') as fh:
             fh.write(content)
 
 
 scripts = ['hg']
 if os.name == 'nt':
     # We remove hg.bat if we are able to build hg.exe.
     scripts.append('contrib/win32/hg.bat')
 
 
 def cancompile(cc, code):
     tmpdir = tempfile.mkdtemp(prefix='hg-install-')
     devnull = oldstderr = None
     try:
         fname = os.path.join(tmpdir, 'testcomp.c')
         f = open(fname, 'w')
         f.write(code)
         f.close()
         # Redirect stderr to /dev/null to hide any error messages
         # from the compiler.
         # This will have to be changed if we ever have to check
         # for a function on Windows.
         devnull = open('/dev/null', 'w')
         oldstderr = os.dup(sys.stderr.fileno())
         os.dup2(devnull.fileno(), sys.stderr.fileno())
         objects = cc.compile([fname], output_dir=tmpdir)
         cc.link_executable(objects, os.path.join(tmpdir, "a.out"))
         return True
     except Exception:
         return False
     finally:
         if oldstderr is not None:
             os.dup2(oldstderr, sys.stderr.fileno())
         if devnull is not None:
             devnull.close()
         shutil.rmtree(tmpdir)
 
 
 # simplified version of distutils.ccompiler.CCompiler.has_function
 # that actually removes its temporary files.
 def hasfunction(cc, funcname):
     code = 'int main(void) { %s(); }\n' % funcname
     return cancompile(cc, code)
 
 
 def hasheader(cc, headername):
     code = '#include <%s>\nint main(void) { return 0; }\n' % headername
     return cancompile(cc, code)
 
 
 # py2exe needs to be installed to work
 try:
     import py2exe
 
     py2exe.Distribution  # silence unused import warning
     py2exeloaded = True
     # import py2exe's patched Distribution class
     from distutils.core import Distribution
 except ImportError:
     py2exeloaded = False
 
 
 def runcmd(cmd, env, cwd=None):
     p = subprocess.Popen(
         cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=env, cwd=cwd
     )
     out, err = p.communicate()
     return p.returncode, out, err
 
 
 class hgcommand:
     def __init__(self, cmd, env):
         self.cmd = cmd
         self.env = env
 
     def run(self, args):
         cmd = self.cmd + args
         returncode, out, err = runcmd(cmd, self.env)
         err = filterhgerr(err)
         if err or returncode != 0:
             print("stderr from '%s':" % (' '.join(cmd)), file=sys.stderr)
             print(err, file=sys.stderr)
             return b''
         return out
 
 
 def filterhgerr(err):
     # If root is executing setup.py, but the repository is owned by
     # another user (as in "sudo python setup.py install") we will get
     # trust warnings since the .hg/hgrc file is untrusted. That is
     # fine, we don't want to load it anyway.  Python may warn about
     # a missing __init__.py in mercurial/locale, we also ignore that.
     err = [
         e
         for e in err.splitlines()
         if (
             not e.startswith(b'not trusting file')
             and not e.startswith(b'warning: Not importing')
             and not e.startswith(b'obsolete feature not enabled')
             and not e.startswith(b'*** failed to import extension')
             and not e.startswith(b'devel-warn:')
             and not (
                 e.startswith(b'(third party extension')
                 and e.endswith(b'or newer of Mercurial; disabling)')
             )
         )
     ]
     return b'\n'.join(b'  ' + e for e in err)
 
 
 def findhg():
     """Try to figure out how we should invoke hg for examining the local
     repository contents.
 
     Returns an hgcommand object."""
     # By default, prefer the "hg" command in the user's path.  This was
     # presumably the hg command that the user used to create this repository.
     #
     # This repository may require extensions or other settings that would not
     # be enabled by running the hg script directly from this local repository.
     hgenv = os.environ.copy()
     # Use HGPLAIN to disable hgrc settings that would change output formatting,
     # and disable localization for the same reasons.
     hgenv['HGPLAIN'] = '1'
     hgenv['LANGUAGE'] = 'C'
     hgcmd = ['hg']
     # Run a simple "hg log" command just to see if using hg from the user's
     # path works and can successfully interact with this repository.  Windows
     # gives precedence to hg.exe in the current directory, so fall back to the
     # python invocation of local hg, where pythonXY.dll can always be found.
     check_cmd = ['log', '-r.', '-Ttest']
     if os.name != 'nt' or not os.path.exists("hg.exe"):
         try:
             retcode, out, err = runcmd(hgcmd + check_cmd, hgenv)
         except EnvironmentError:
             retcode = -1
         if retcode == 0 and not filterhgerr(err):
             return hgcommand(hgcmd, hgenv)
 
     # Fall back to trying the local hg installation.
     hgenv = localhgenv()
     hgcmd = [sys.executable, 'hg']
     try:
         retcode, out, err = runcmd(hgcmd + check_cmd, hgenv)
     except EnvironmentError:
         retcode = -1
     if retcode == 0 and not filterhgerr(err):
         return hgcommand(hgcmd, hgenv)
 
     raise SystemExit(
         'Unable to find a working hg binary to extract the '
         'version from the repository tags'
     )
 
 
 def localhgenv():
     """Get an environment dictionary to use for invoking or importing
     mercurial from the local repository."""
     # Execute hg out of this directory with a custom environment which takes
     # care to not use any hgrc files and do no localization.
     env = {
         'HGMODULEPOLICY': 'py',
         'HGRCPATH': '',
         'LANGUAGE': 'C',
         'PATH': '',
     }  # make pypi modules that use os.environ['PATH'] happy
     if 'LD_LIBRARY_PATH' in os.environ:
         env['LD_LIBRARY_PATH'] = os.environ['LD_LIBRARY_PATH']
     if 'SystemRoot' in os.environ:
         # SystemRoot is required by Windows to load various DLLs.  See:
         # https://bugs.python.org/issue13524#msg148850
         env['SystemRoot'] = os.environ['SystemRoot']
     return env
 
 
 version = ''
 
 if os.path.isdir('.hg'):
     hg = findhg()
     cmd = ['log', '-r', '.', '--template', '{tags}\n']
     numerictags = [t for t in sysstr(hg.run(cmd)).split() if t[0:1].isdigit()]
     hgid = sysstr(hg.run(['id', '-i'])).strip()
     if not hgid:
         # Bail out if hg is having problems interacting with this repository,
         # rather than falling through and producing a bogus version number.
         # Continuing with an invalid version number will break extensions
         # that define minimumhgversion.
         raise SystemExit('Unable to determine hg version from local repository')
     if numerictags:  # tag(s) found
         version = numerictags[-1]
         if hgid.endswith('+'):  # propagate the dirty status to the tag
             version += '+'
     else:  # no tag found
         ltagcmd = ['parents', '--template', '{latesttag}']
         ltag = sysstr(hg.run(ltagcmd))
         changessincecmd = ['log', '-T', 'x\n', '-r', "only(.,'%s')" % ltag]
         changessince = len(hg.run(changessincecmd).splitlines())
         version = '%s+hg%s.%s' % (ltag, changessince, hgid)
     if version.endswith('+'):
         version = version[:-1] + 'local' + time.strftime('%Y%m%d')
 elif os.path.exists('.hg_archival.txt'):
     kw = dict(
         [[t.strip() for t in l.split(':', 1)] for l in open('.hg_archival.txt')]
     )
     if 'tag' in kw:
         version = kw['tag']
     elif 'latesttag' in kw:
         if 'changessincelatesttag' in kw:
             version = (
                 '%(latesttag)s+hg%(changessincelatesttag)s.%(node).12s' % kw
             )
         else:
             version = '%(latesttag)s+hg%(latesttagdistance)s.%(node).12s' % kw
     else:
         version = '0+hg' + kw.get('node', '')[:12]
 elif os.path.exists('mercurial/__version__.py'):
     with open('mercurial/__version__.py') as f:
         data = f.read()
     version = re.search('version = b"(.*)"', data).group(1)
 
 if version:
     versionb = version
     if not isinstance(versionb, bytes):
         versionb = versionb.encode('ascii')
 
     write_if_changed(
         'mercurial/__version__.py',
         b''.join(
             [
                 b'# this file is autogenerated by setup.py\n'
                 b'version = b"%s"\n' % versionb,
             ]
         ),
     )
 
 
 class hgbuild(build):
     # Insert hgbuildmo first so that files in mercurial/locale/ are found
     # when build_py is run next.
     sub_commands = [('build_mo', None)] + build.sub_commands
 
 
 class hgbuildmo(build):
 
     description = "build translations (.mo files)"
 
     def run(self):
         if not find_executable('msgfmt'):
             self.warn(
                 "could not find msgfmt executable, no translations "
                 "will be built"
             )
             return
 
         podir = 'i18n'
         if not os.path.isdir(podir):
             self.warn("could not find %s/ directory" % podir)
             return
 
         join = os.path.join
         for po in os.listdir(podir):
             if not po.endswith('.po'):
                 continue
             pofile = join(podir, po)
             modir = join('locale', po[:-3], 'LC_MESSAGES')
             mofile = join(modir, 'hg.mo')
             mobuildfile = join('mercurial', mofile)
             cmd = ['msgfmt', '-v', '-o', mobuildfile, pofile]
             if sys.platform != 'sunos5':
                 # msgfmt on Solaris does not know about -c
                 cmd.append('-c')
             self.mkpath(join('mercurial', modir))
             self.make_file([pofile], mobuildfile, spawn, (cmd,))
 
 
 class hgdist(Distribution):
     pure = False
     rust = False
     no_rust = False
     cffi = ispypy
 
     global_options = Distribution.global_options + [
         ('pure', None, "use pure (slow) Python code instead of C extensions"),
         ('rust', None, "use Rust extensions additionally to C extensions"),
         (
             'no-rust',
             None,
             "do not use Rust extensions additionally to C extensions",
         ),
     ]
 
     negative_opt = Distribution.negative_opt.copy()
     boolean_options = ['pure', 'rust', 'no-rust']
     negative_opt['no-rust'] = 'rust'
 
     def _set_command_options(self, command_obj, option_dict=None):
         # Not all distutils versions in the wild have boolean_options.
         # This should be cleaned up when we're Python 3 only.
         command_obj.boolean_options = (
             getattr(command_obj, 'boolean_options', []) + self.boolean_options
         )
         return Distribution._set_command_options(
             self, command_obj, option_dict=option_dict
         )
 
     def parse_command_line(self):
         ret = Distribution.parse_command_line(self)
         if not (self.rust or self.no_rust):
             hgrustext = os.environ.get('HGWITHRUSTEXT')
             # TODO record it for proper rebuild upon changes
             # (see mercurial/__modulepolicy__.py)
             if hgrustext != 'cpython' and hgrustext is not None:
                 if hgrustext:
                     msg = 'unknown HGWITHRUSTEXT value: %s' % hgrustext
                     print(msg, file=sys.stderr)
                 hgrustext = None
             self.rust = hgrustext is not None
             self.no_rust = not self.rust
         return ret
 
     def has_ext_modules(self):
         # self.ext_modules is emptied in hgbuildpy.finalize_options which is
         # too late for some cases
         return not self.pure and Distribution.has_ext_modules(self)
 
 
 # This is ugly as a one-liner. So use a variable.
 buildextnegops = dict(getattr(build_ext, 'negative_options', {}))
 buildextnegops['no-zstd'] = 'zstd'
 buildextnegops['no-rust'] = 'rust'
 
 
 class hgbuildext(build_ext):
     user_options = build_ext.user_options + [
         ('zstd', None, 'compile zstd bindings [default]'),
         ('no-zstd', None, 'do not compile zstd bindings'),
         (
             'rust',
             None,
             'compile Rust extensions if they are in use '
             '(requires Cargo) [default]',
         ),
         ('no-rust', None, 'do not compile Rust extensions'),
     ]
 
     boolean_options = build_ext.boolean_options + ['zstd', 'rust']
     negative_opt = buildextnegops
 
     def initialize_options(self):
         self.zstd = True
         self.rust = True
 
         return build_ext.initialize_options(self)
 
     def finalize_options(self):
         # Unless overridden by the end user, build extensions in parallel.
         # Only influences behavior on Python 3.5+.
         if getattr(self, 'parallel', None) is None:
             self.parallel = True
 
         return build_ext.finalize_options(self)
 
     def build_extensions(self):
         ruststandalones = [
             e for e in self.extensions if isinstance(e, RustStandaloneExtension)
         ]
         self.extensions = [
             e for e in self.extensions if e not in ruststandalones
         ]
         # Filter out zstd if disabled via argument.
         if not self.zstd:
             self.extensions = [
                 e for e in self.extensions if e.name != 'mercurial.zstd'
             ]
 
         # Build Rust standalone extensions if it'll be used
         # and its build is not explicitly disabled (for external build
         # as Linux distributions would do)
         if self.distribution.rust and self.rust:
             if not sys.platform.startswith('linux'):
                 self.warn(
                     "rust extensions have only been tested on Linux "
                     "and may not behave correctly on other platforms"
                 )
 
             for rustext in ruststandalones:
                 rustext.build('' if self.inplace else self.build_lib)
 
         return build_ext.build_extensions(self)
 
     def build_extension(self, ext):
         if (
             self.distribution.rust
             and self.rust
             and isinstance(ext, RustExtension)
         ):
             ext.rustbuild()
         try:
             build_ext.build_extension(self, ext)
         except CCompilerError:
             if not getattr(ext, 'optional', False):
                 raise
             log.warn(
                 "Failed to build optional extension '%s' (skipping)", ext.name
             )
 
 
 class hgbuildscripts(build_scripts):
     def run(self):
         if os.name != 'nt' or self.distribution.pure:
             return build_scripts.run(self)
 
         exebuilt = False
         try:
             self.run_command('build_hgexe')
             exebuilt = True
         except (DistutilsError, CCompilerError):
             log.warn('failed to build optional hg.exe')
 
         if exebuilt:
             # Copying hg.exe to the scripts build directory ensures it is
             # installed by the install_scripts command.
             hgexecommand = self.get_finalized_command('build_hgexe')
             dest = os.path.join(self.build_dir, 'hg.exe')
             self.mkpath(self.build_dir)
             self.copy_file(hgexecommand.hgexepath, dest)
 
             # Remove hg.bat because it is redundant with hg.exe.
             self.scripts.remove('contrib/win32/hg.bat')
 
         return build_scripts.run(self)
 
 
 class hgbuildpy(build_py):
     def finalize_options(self):
         build_py.finalize_options(self)
 
         if self.distribution.pure:
             self.distribution.ext_modules = []
         elif self.distribution.cffi:
             from mercurial.cffi import (
                 bdiffbuild,
                 mpatchbuild,
             )
 
             exts = [
                 mpatchbuild.ffi.distutils_extension(),
                 bdiffbuild.ffi.distutils_extension(),
             ]
             # cffi modules go here
             if sys.platform == 'darwin':
                 from mercurial.cffi import osutilbuild
 
                 exts.append(osutilbuild.ffi.distutils_extension())
             self.distribution.ext_modules = exts
         else:
             h = os.path.join(get_python_inc(), 'Python.h')
             if not os.path.exists(h):
                 raise SystemExit(
                     'Python headers are required to build '
                     'Mercurial but weren\'t found in %s' % h
                 )
 
     def run(self):
         basepath = os.path.join(self.build_lib, 'mercurial')
         self.mkpath(basepath)
 
         rust = self.distribution.rust
         if self.distribution.pure:
             modulepolicy = 'py'
         elif self.build_lib == '.':
             # in-place build should run without rebuilding and Rust extensions
             modulepolicy = 'rust+c-allow' if rust else 'allow'
         else:
             modulepolicy = 'rust+c' if rust else 'c'
 
         content = b''.join(
             [
                 b'# this file is autogenerated by setup.py\n',
                 b'modulepolicy = b"%s"\n' % modulepolicy.encode('ascii'),
             ]
         )
         write_if_changed(os.path.join(basepath, '__modulepolicy__.py'), content)
 
         build_py.run(self)
 
 
 class buildhgextindex(Command):
     description = 'generate prebuilt index of hgext (for frozen package)'
     user_options = []
     _indexfilename = 'hgext/__index__.py'
 
     def initialize_options(self):
         pass
 
     def finalize_options(self):
         pass
 
     def run(self):
         if os.path.exists(self._indexfilename):
             with open(self._indexfilename, 'w') as f:
                 f.write('# empty\n')
 
         # here no extension enabled, disabled() lists up everything
         code = (
             'import pprint; from mercurial import extensions; '
             'ext = extensions.disabled();'
             'ext.pop("__index__", None);'
             'pprint.pprint(ext)'
         )
         returncode, out, err = runcmd(
             [sys.executable, '-c', code], localhgenv()
         )
         if err or returncode != 0:
             raise DistutilsExecError(err)
 
         with open(self._indexfilename, 'wb') as f:
             f.write(b'# this file is autogenerated by setup.py\n')
             f.write(b'docs = ')
             f.write(out)
 
 
 class buildhgexe(build_ext):
     description = 'compile hg.exe from mercurial/exewrapper.c'
     user_options = build_ext.user_options + [
         (
             'long-paths-support',
             None,
             'enable support for long paths on '
             'Windows (off by default and '
             'experimental)',
         ),
     ]
 
     LONG_PATHS_MANIFEST = """
     <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
     <assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
         <application>
             <windowsSettings
             xmlns:ws2="http://schemas.microsoft.com/SMI/2016/WindowsSettings">
                 <ws2:longPathAware>true</ws2:longPathAware>
             </windowsSettings>
         </application>
     </assembly>"""
 
     def initialize_options(self):
         build_ext.initialize_options(self)
         self.long_paths_support = False
 
     def build_extensions(self):
         if os.name != 'nt':
             return
         if isinstance(self.compiler, HackedMingw32CCompiler):
             self.compiler.compiler_so = self.compiler.compiler  # no -mdll
             self.compiler.dll_libraries = []  # no -lmsrvc90
 
         pythonlib = None
 
         dir = os.path.dirname(self.get_ext_fullpath('dummy'))
         self.hgtarget = os.path.join(dir, 'hg')
 
         if getattr(sys, 'dllhandle', None):
             # Different Python installs can have different Python library
             # names. e.g. the official CPython distribution uses pythonXY.dll
             # and MinGW uses libpythonX.Y.dll.
             _kernel32 = ctypes.windll.kernel32
             _kernel32.GetModuleFileNameA.argtypes = [
                 ctypes.c_void_p,
                 ctypes.c_void_p,
                 ctypes.c_ulong,
             ]
             _kernel32.GetModuleFileNameA.restype = ctypes.c_ulong
             size = 1000
             buf = ctypes.create_string_buffer(size + 1)
             filelen = _kernel32.GetModuleFileNameA(
                 sys.dllhandle, ctypes.byref(buf), size
             )
 
             if filelen > 0 and filelen != size:
                 dllbasename = os.path.basename(buf.value)
                 if not dllbasename.lower().endswith(b'.dll'):
                     raise SystemExit(
                         'Python DLL does not end with .dll: %s' % dllbasename
                     )
                 pythonlib = dllbasename[:-4]
 
                 # Copy the pythonXY.dll next to the binary so that it runs
                 # without tampering with PATH.
                 dest = os.path.join(
                     os.path.dirname(self.hgtarget),
                     os.fsdecode(dllbasename),
                 )
 
                 if not os.path.exists(dest):
                     shutil.copy(buf.value, dest)
 
                 # Also overwrite python3.dll so that hgext.git is usable.
                 # TODO: also handle the MSYS flavor
                 python_x = os.path.join(
                     os.path.dirname(os.fsdecode(buf.value)),
                     "python3.dll",
                 )
 
                 if os.path.exists(python_x):
                     dest = os.path.join(
                         os.path.dirname(self.hgtarget),
                         os.path.basename(python_x),
                     )
 
                     shutil.copy(python_x, dest)
 
         if not pythonlib:
             log.warn(
                 'could not determine Python DLL filename; assuming pythonXY'
             )
 
             hv = sys.hexversion
             pythonlib = b'python%d%d' % (hv >> 24, (hv >> 16) & 0xFF)
 
         log.info('using %s as Python library name' % pythonlib)
         with open('mercurial/hgpythonlib.h', 'wb') as f:
             f.write(b'/* this file is autogenerated by setup.py */\n')
             f.write(b'#define HGPYTHONLIB "%s"\n' % pythonlib)
 
         objects = self.compiler.compile(
             ['mercurial/exewrapper.c'],
             output_dir=self.build_temp,
             macros=[('_UNICODE', None), ('UNICODE', None)],
         )
         self.compiler.link_executable(
             objects, self.hgtarget, libraries=[], output_dir=self.build_temp
         )
         if self.long_paths_support:
             self.addlongpathsmanifest()
 
     def addlongpathsmanifest(self):
         r"""Add manifest pieces so that hg.exe understands long paths
 
         This is an EXPERIMENTAL feature, use with care.
         To enable long paths support, one needs to do two things:
         - build Mercurial with --long-paths-support option
         - change HKLM\SYSTEM\CurrentControlSet\Control\FileSystem\
                  LongPathsEnabled to have value 1.
 
         Please ignore 'warning 81010002: Unrecognized Element "longPathAware"';
         it happens because Mercurial uses mt.exe circa 2008, which is not
         yet aware of long paths support in the manifest (I think so at least).
         This does not stop mt.exe from embedding/merging the XML properly.
 
         Why resource #1 should be used for .exe manifests? I don't know and
         wasn't able to find an explanation for mortals. But it seems to work.
         """
         exefname = self.compiler.executable_filename(self.hgtarget)
         fdauto, manfname = tempfile.mkstemp(suffix='.hg.exe.manifest')
         os.close(fdauto)
         with open(manfname, 'w') as f:
             f.write(self.LONG_PATHS_MANIFEST)
         log.info("long paths manifest is written to '%s'" % manfname)
         inputresource = '-inputresource:%s;#1' % exefname
         outputresource = '-outputresource:%s;#1' % exefname
         log.info("running mt.exe to update hg.exe's manifest in-place")
         # supplying both -manifest and -inputresource to mt.exe makes
         # it merge the embedded and supplied manifests in the -outputresource
         self.spawn(
             [
                 'mt.exe',
                 '-nologo',
                 '-manifest',
                 manfname,
                 inputresource,
                 outputresource,
             ]
         )
         log.info("done updating hg.exe's manifest")
         os.remove(manfname)
 
     @property
     def hgexepath(self):
         dir = os.path.dirname(self.get_ext_fullpath('dummy'))
         return os.path.join(self.build_temp, dir, 'hg.exe')
 
 
 class hgbuilddoc(Command):
     description = 'build documentation'
     user_options = [
         ('man', None, 'generate man pages'),
         ('html', None, 'generate html pages'),
     ]
 
     def initialize_options(self):
         self.man = None
         self.html = None
 
     def finalize_options(self):
         # If --man or --html are set, only generate what we're told to.
         # Otherwise generate everything.
         have_subset = self.man is not None or self.html is not None
 
         if have_subset:
             self.man = True if self.man else False
             self.html = True if self.html else False
         else:
             self.man = True
             self.html = True
 
     def run(self):
         def normalizecrlf(p):
             with open(p, 'rb') as fh:
                 orig = fh.read()
 
             if b'\r\n' not in orig:
                 return
 
             log.info('normalizing %s to LF line endings' % p)
             with open(p, 'wb') as fh:
                 fh.write(orig.replace(b'\r\n', b'\n'))
 
         def gentxt(root):
             txt = 'doc/%s.txt' % root
             log.info('generating %s' % txt)
             res, out, err = runcmd(
                 [sys.executable, 'gendoc.py', root], os.environ, cwd='doc'
             )
             if res:
                 raise SystemExit(
                     'error running gendoc.py: %s'
                     % '\n'.join([sysstr(out), sysstr(err)])
                 )
 
             with open(txt, 'wb') as fh:
                 fh.write(out)
 
         def gengendoc(root):
             gendoc = 'doc/%s.gendoc.txt' % root
 
             log.info('generating %s' % gendoc)
             res, out, err = runcmd(
                 [sys.executable, 'gendoc.py', '%s.gendoc' % root],
                 os.environ,
                 cwd='doc',
             )
             if res:
                 raise SystemExit(
                     'error running gendoc: %s'
                     % '\n'.join([sysstr(out), sysstr(err)])
                 )
 
             with open(gendoc, 'wb') as fh:
                 fh.write(out)
 
         def genman(root):
             log.info('generating doc/%s' % root)
             res, out, err = runcmd(
                 [
                     sys.executable,
                     'runrst',
                     'hgmanpage',
                     '--halt',
                     'warning',
                     '--strip-elements-with-class',
                     'htmlonly',
                     '%s.txt' % root,
                     root,
                 ],
                 os.environ,
                 cwd='doc',
             )
             if res:
                 raise SystemExit(
                     'error running runrst: %s'
                     % '\n'.join([sysstr(out), sysstr(err)])
                 )
 
             normalizecrlf('doc/%s' % root)
 
         def genhtml(root):
             log.info('generating doc/%s.html' % root)
             res, out, err = runcmd(
                 [
                     sys.executable,
                     'runrst',
                     'html',
                     '--halt',
                     'warning',
                     '--link-stylesheet',
                     '--stylesheet-path',
                     'style.css',
                     '%s.txt' % root,
                     '%s.html' % root,
                 ],
                 os.environ,
                 cwd='doc',
             )
             if res:
                 raise SystemExit(
                     'error running runrst: %s'
                     % '\n'.join([sysstr(out), sysstr(err)])
                 )
 
             normalizecrlf('doc/%s.html' % root)
 
         # This logic is duplicated in doc/Makefile.
         sources = {
             f
             for f in os.listdir('mercurial/helptext')
             if re.search(r'[0-9]\.txt$', f)
         }
 
         # common.txt is a one-off.
         gentxt('common')
 
         for source in sorted(sources):
             assert source[-4:] == '.txt'
             root = source[:-4]
 
             gentxt(root)
             gengendoc(root)
 
             if self.man:
                 genman(root)
             if self.html:
                 genhtml(root)
 
 
 class hginstall(install):
 
     user_options = install.user_options + [
         (
             'old-and-unmanageable',
             None,
             'noop, present for eggless setuptools compat',
         ),
         (
             'single-version-externally-managed',
             None,
             'noop, present for eggless setuptools compat',
         ),
     ]
 
+    sub_commands = install.sub_commands + [
+        ('install_completion', lambda self: True)
+    ]
+
     # Also helps setuptools not be sad while we refuse to create eggs.
     single_version_externally_managed = True
 
     def get_sub_commands(self):
         # Screen out egg related commands to prevent egg generation.  But allow
         # mercurial.egg-info generation, since that is part of modern
         # packaging.
         excl = {'bdist_egg'}
         return filter(lambda x: x not in excl, install.get_sub_commands(self))
 
 
 class hginstalllib(install_lib):
     """
     This is a specialization of install_lib that replaces the copy_file used
     there so that it supports setting the mode of files after copying them,
     instead of just preserving the mode that the files originally had.  If your
     system has a umask of something like 027, preserving the permissions when
     copying will lead to a broken install.
 
     Note that just passing keep_permissions=False to copy_file would be
     insufficient, as it might still be applying a umask.
     """
 
     def run(self):
         realcopyfile = file_util.copy_file
 
         def copyfileandsetmode(*args, **kwargs):
             src, dst = args[0], args[1]
             dst, copied = realcopyfile(*args, **kwargs)
             if copied:
                 st = os.stat(src)
                 # Persist executable bit (apply it to group and other if user
                 # has it)
                 if st[stat.ST_MODE] & stat.S_IXUSR:
                     setmode = int('0755', 8)
                 else:
                     setmode = int('0644', 8)
                 m = stat.S_IMODE(st[stat.ST_MODE])
                 m = (m & ~int('0777', 8)) | setmode
                 os.chmod(dst, m)
 
         file_util.copy_file = copyfileandsetmode
         try:
             install_lib.run(self)
         finally:
             file_util.copy_file = realcopyfile
 
 
 class hginstallscripts(install_scripts):
     """
     This is a specialization of install_scripts that replaces the @LIBDIR@ with
     the configured directory for modules. If possible, the path is made relative
     to the directory for scripts.
     """
 
     def initialize_options(self):
         install_scripts.initialize_options(self)
 
         self.install_lib = None
 
     def finalize_options(self):
         install_scripts.finalize_options(self)
         self.set_undefined_options('install', ('install_lib', 'install_lib'))
 
     def run(self):
         install_scripts.run(self)
 
         # It only makes sense to replace @LIBDIR@ with the install path if
         # the install path is known. For wheels, the logic below calculates
         # the libdir to be "../..". This is because the internal layout of a
         # wheel archive looks like:
         #
         #   mercurial-3.6.1.data/scripts/hg
         #   mercurial/__init__.py
         #
         # When installing wheels, the subdirectories of the "<pkg>.data"
         # directory are translated to system local paths and files therein
         # are copied in place. The mercurial/* files are installed into the
         # site-packages directory. However, the site-packages directory
         # isn't known until wheel install time. This means we have no clue
         # at wheel generation time what the installed site-packages directory
         # will be. And, wheels don't appear to provide the ability to register
         # custom code to run during wheel installation. This all means that
         # we can't reliably set the libdir in wheels: the default behavior
         # of looking in sys.path must do.
 
         if (
             os.path.splitdrive(self.install_dir)[0]
             != os.path.splitdrive(self.install_lib)[0]
         ):
             # can't make relative paths from one drive to another, so use an
             # absolute path instead
             libdir = self.install_lib
         else:
             libdir = os.path.relpath(self.install_lib, self.install_dir)
 
         for outfile in self.outfiles:
             with open(outfile, 'rb') as fp:
                 data = fp.read()
 
             # skip binary files
             if b'\0' in data:
                 continue
 
             # During local installs, the shebang will be rewritten to the final
             # install path. During wheel packaging, the shebang has a special
             # value.
             if data.startswith(b'#!python'):
                 log.info(
                     'not rewriting @LIBDIR@ in %s because install path '
                     'not known' % outfile
                 )
                 continue
 
             data = data.replace(b'@LIBDIR@', libdir.encode('unicode_escape'))
             with open(outfile, 'wb') as fp:
                 fp.write(data)
 
 
+class hginstallcompletion(Command):
+    description = 'Install shell completion'
+
+    def initialize_options(self):
+        self.install_dir = None
+
+    def finalize_options(self):
+        self.set_undefined_options(
+            'install_data', ('install_dir', 'install_dir')
+        )
+
+    def run(self):
+        for src, dir_path, dest in (
+            (
+                'bash_completion',
+                ('share', 'bash-completion', 'completions'),
+                'hg',
+            ),
+            ('zsh_completion', ('share', 'zsh', 'site-functions'), '_hg'),
+        ):
+            dir = os.path.join(self.install_dir, *dir_path)
+            self.mkpath(dir)
+            self.copy_file(
+                os.path.join('contrib', src), os.path.join(dir, dest)
+            )
+
+
 # virtualenv installs custom distutils/__init__.py and
 # distutils/distutils.cfg files which essentially proxy back to the
 # "real" distutils in the main Python install. The presence of this
 # directory causes py2exe to pick up the "hacked" distutils package
 # from the virtualenv and "import distutils" will fail from the py2exe
 # build because the "real" distutils files can't be located.
 #
 # We work around this by monkeypatching the py2exe code finding Python
 # modules to replace the found virtualenv distutils modules with the
 # original versions via filesystem scanning. This is a bit hacky. But
 # it allows us to use virtualenvs for py2exe packaging, which is more
 # deterministic and reproducible.
 #
 # It's worth noting that the common StackOverflow suggestions for this
 # problem involve copying the original distutils files into the
 # virtualenv or into the staging directory after setup() is invoked.
 # The former is very brittle and can easily break setup(). Our hacking
 # of the found modules routine has a similar result as copying the files
 # manually. But it makes fewer assumptions about how py2exe works and
 # is less brittle.
 
 # This only catches virtualenvs made with virtualenv (as opposed to
 # venv, which is likely what Python 3 uses).
 py2exehacked = py2exeloaded and getattr(sys, 'real_prefix', None) is not None
 
 if py2exehacked:
     from distutils.command.py2exe import py2exe as buildpy2exe
     from py2exe.mf import Module as py2exemodule
 
     class hgbuildpy2exe(buildpy2exe):
         def find_needed_modules(self, mf, files, modules):
             res = buildpy2exe.find_needed_modules(self, mf, files, modules)
 
             # Replace virtualenv's distutils modules with the real ones.
             modules = {}
             for k, v in res.modules.items():
                 if k != 'distutils' and not k.startswith('distutils.'):
                     modules[k] = v
 
             res.modules = modules
 
             import opcode
 
             distutilsreal = os.path.join(
                 os.path.dirname(opcode.__file__), 'distutils'
             )
 
             for root, dirs, files in os.walk(distutilsreal):
                 for f in sorted(files):
                     if not f.endswith('.py'):
                         continue
 
                     full = os.path.join(root, f)
 
                     parents = ['distutils']
 
                     if root != distutilsreal:
                         rel = os.path.relpath(root, distutilsreal)
                         parents.extend(p for p in rel.split(os.sep))
 
                     modname = '%s.%s' % ('.'.join(parents), f[:-3])
 
                     if modname.startswith('distutils.tests.'):
                         continue
 
                     if modname.endswith('.__init__'):
                         modname = modname[: -len('.__init__')]
                         path = os.path.dirname(full)
                     else:
                         path = None
 
                     res.modules[modname] = py2exemodule(
                         modname, full, path=path
                     )
 
             if 'distutils' not in res.modules:
                 raise SystemExit('could not find distutils modules')
 
             return res
 
 
 cmdclass = {
     'build': hgbuild,
     'build_doc': hgbuilddoc,
     'build_mo': hgbuildmo,
     'build_ext': hgbuildext,
     'build_py': hgbuildpy,
     'build_scripts': hgbuildscripts,
     'build_hgextindex': buildhgextindex,
     'install': hginstall,
+    'install_completion': hginstallcompletion,
     'install_lib': hginstalllib,
     'install_scripts': hginstallscripts,
     'build_hgexe': buildhgexe,
 }
 
 if py2exehacked:
     cmdclass['py2exe'] = hgbuildpy2exe
 
 packages = [
     'mercurial',
     'mercurial.cext',
     'mercurial.cffi',
     'mercurial.defaultrc',
     'mercurial.dirstateutils',
     'mercurial.helptext',
     'mercurial.helptext.internals',
     'mercurial.hgweb',
     'mercurial.interfaces',
     'mercurial.pure',
     'mercurial.templates',
     'mercurial.thirdparty',
     'mercurial.thirdparty.attr',
     'mercurial.thirdparty.zope',
     'mercurial.thirdparty.zope.interface',
     'mercurial.upgrade_utils',
     'mercurial.utils',
     'mercurial.revlogutils',
     'mercurial.testing',
     'hgext',
     'hgext.convert',
     'hgext.fsmonitor',
     'hgext.fastannotate',
     'hgext.fsmonitor.pywatchman',
     'hgext.git',
     'hgext.highlight',
     'hgext.hooklib',
     'hgext.infinitepush',
     'hgext.largefiles',
     'hgext.lfs',
     'hgext.narrow',
     'hgext.remotefilelog',
     'hgext.zeroconf',
     'hgext3rd',
     'hgdemandimport',
 ]
 
 for name in os.listdir(os.path.join('mercurial', 'templates')):
     if name != '__pycache__' and os.path.isdir(
         os.path.join('mercurial', 'templates', name)
     ):
         packages.append('mercurial.templates.%s' % name)
 
 if 'HG_PY2EXE_EXTRA_INSTALL_PACKAGES' in os.environ:
     # py2exe can't cope with namespace packages very well, so we have to
     # install any hgext3rd.* extensions that we want in the final py2exe
     # image here. This is gross, but you gotta do what you gotta do.
     packages.extend(os.environ['HG_PY2EXE_EXTRA_INSTALL_PACKAGES'].split(' '))
 
 common_depends = [
     'mercurial/bitmanipulation.h',
     'mercurial/compat.h',
     'mercurial/cext/util.h',
 ]
 common_include_dirs = ['mercurial']
 
 common_cflags = []
 
 # MSVC 2008 still needs declarations at the top of the scope, but Python 3.9
 # makes declarations not at the top of a scope in the headers.
 if os.name != 'nt' and sys.version_info[1] < 9:
     common_cflags = ['-Werror=declaration-after-statement']
 
 osutil_cflags = []
 osutil_ldflags = []
 
 # platform specific macros
 for plat, func in [('bsd', 'setproctitle')]:
     if re.search(plat, sys.platform) and hasfunction(new_compiler(), func):
         osutil_cflags.append('-DHAVE_%s' % func.upper())
 
 for plat, macro, code in [
     (
         'bsd|darwin',
         'BSD_STATFS',
         '''
      #include <sys/param.h>
      #include <sys/mount.h>
      int main() { struct statfs s; return sizeof(s.f_fstypename); }
      ''',
     ),
     (
         'linux',
         'LINUX_STATFS',
         '''
      #include <linux/magic.h>
      #include <sys/vfs.h>
      int main() { struct statfs s; return sizeof(s.f_type); }
      ''',
     ),
 ]:
     if re.search(plat, sys.platform) and cancompile(new_compiler(), code):
         osutil_cflags.append('-DHAVE_%s' % macro)
 
 if sys.platform == 'darwin':
     osutil_ldflags += ['-framework', 'ApplicationServices']
 
 if sys.platform == 'sunos5':
     osutil_ldflags += ['-lsocket']
 
 xdiff_srcs = [
     'mercurial/thirdparty/xdiff/xdiffi.c',
     'mercurial/thirdparty/xdiff/xprepare.c',
     'mercurial/thirdparty/xdiff/xutils.c',
 ]
 
 xdiff_headers = [
     'mercurial/thirdparty/xdiff/xdiff.h',
     'mercurial/thirdparty/xdiff/xdiffi.h',
     'mercurial/thirdparty/xdiff/xinclude.h',
     'mercurial/thirdparty/xdiff/xmacros.h',
     'mercurial/thirdparty/xdiff/xprepare.h',
     'mercurial/thirdparty/xdiff/xtypes.h',
     'mercurial/thirdparty/xdiff/xutils.h',
 ]
 
 
 class RustCompilationError(CCompilerError):
     """Exception class for Rust compilation errors."""
 
 
 class RustExtension(Extension):
     """Base classes for concrete Rust Extension classes."""
 
     rusttargetdir = os.path.join('rust', 'target', 'release')
 
     def __init__(self, mpath, sources, rustlibname, subcrate, **kw):
         Extension.__init__(self, mpath, sources, **kw)
         srcdir = self.rustsrcdir = os.path.join('rust', subcrate)
 
         # adding Rust source and control files to depends so that the extension
         # gets rebuilt if they've changed
         self.depends.append(os.path.join(srcdir, 'Cargo.toml'))
         cargo_lock = os.path.join(srcdir, 'Cargo.lock')
         if os.path.exists(cargo_lock):
             self.depends.append(cargo_lock)
         for dirpath, subdir, fnames in os.walk(os.path.join(srcdir, 'src')):
             self.depends.extend(
                 os.path.join(dirpath, fname)
                 for fname in fnames
                 if os.path.splitext(fname)[1] == '.rs'
             )
 
     @staticmethod
     def rustdylibsuffix():
         """Return the suffix for shared libraries produced by rustc.
 
         See also: https://doc.rust-lang.org/reference/linkage.html
         """
         if sys.platform == 'darwin':
             return '.dylib'
         elif os.name == 'nt':
             return '.dll'
         else:
             return '.so'
 
     def rustbuild(self):
         env = os.environ.copy()
         if 'HGTEST_RESTOREENV' in env:
             # Mercurial tests change HOME to a temporary directory,
             # but, if installed with rustup, the Rust toolchain needs
             # HOME to be correct (otherwise the 'no default toolchain'
             # error message is issued and the build fails).
             # This happens currently with test-hghave.t, which does
             # invoke this build.
 
             # Unix only fix (os.path.expanduser not really reliable if
             # HOME is shadowed like this)
             import pwd
 
             env['HOME'] = pwd.getpwuid(os.getuid()).pw_dir
 
         cargocmd = ['cargo', 'rustc', '--release']
 
         rust_features = env.get("HG_RUST_FEATURES")
         if rust_features:
             cargocmd.extend(('--features', rust_features))
 
         cargocmd.append('--')
         if sys.platform == 'darwin':
             cargocmd.extend(
                 ("-C", "link-arg=-undefined", "-C", "link-arg=dynamic_lookup")
             )
         try:
             subprocess.check_call(cargocmd, env=env, cwd=self.rustsrcdir)
         except OSError as exc:
             if exc.errno == errno.ENOENT:
                 raise RustCompilationError("Cargo not found")
             elif exc.errno == errno.EACCES:
                 raise RustCompilationError(
                     "Cargo found, but permission to execute it is denied"
                 )
             else:
                 raise
         except subprocess.CalledProcessError:
             raise RustCompilationError(
                 "Cargo failed. Working directory: %r, "
                 "command: %r, environment: %r"
                 % (self.rustsrcdir, cargocmd, env)
             )
 
 
 class RustStandaloneExtension(RustExtension):
     def __init__(self, pydottedname, rustcrate, dylibname, **kw):
         RustExtension.__init__(
             self, pydottedname, [], dylibname, rustcrate, **kw
         )
         self.dylibname = dylibname
 
     def build(self, target_dir):
         self.rustbuild()
         target = [target_dir]
         target.extend(self.name.split('.'))
         target[-1] += DYLIB_SUFFIX
         shutil.copy2(
             os.path.join(
                 self.rusttargetdir, self.dylibname + self.rustdylibsuffix()
             ),
             os.path.join(*target),
         )
 
 
 extmodules = [
     Extension(
         'mercurial.cext.base85',
         ['mercurial/cext/base85.c'],
         include_dirs=common_include_dirs,
         extra_compile_args=common_cflags,
         depends=common_depends,
     ),
     Extension(
         'mercurial.cext.bdiff',
         ['mercurial/bdiff.c', 'mercurial/cext/bdiff.c'] + xdiff_srcs,
         include_dirs=common_include_dirs,
         extra_compile_args=common_cflags,
         depends=common_depends + ['mercurial/bdiff.h'] + xdiff_headers,
     ),
     Extension(
         'mercurial.cext.mpatch',
         ['mercurial/mpatch.c', 'mercurial/cext/mpatch.c'],
         include_dirs=common_include_dirs,
         extra_compile_args=common_cflags,
         depends=common_depends,
     ),
     Extension(
         'mercurial.cext.parsers',
         [
             'mercurial/cext/charencode.c',
             'mercurial/cext/dirs.c',
             'mercurial/cext/manifest.c',
             'mercurial/cext/parsers.c',
             'mercurial/cext/pathencode.c',
             'mercurial/cext/revlog.c',
         ],
         include_dirs=common_include_dirs,
         extra_compile_args=common_cflags,
         depends=common_depends
         + [
             'mercurial/cext/charencode.h',
             'mercurial/cext/revlog.h',
         ],
     ),
     Extension(
         'mercurial.cext.osutil',
         ['mercurial/cext/osutil.c'],
         include_dirs=common_include_dirs,
         extra_compile_args=common_cflags + osutil_cflags,
         extra_link_args=osutil_ldflags,
         depends=common_depends,
     ),
     Extension(
         'mercurial.thirdparty.zope.interface._zope_interface_coptimizations',
         [
             'mercurial/thirdparty/zope/interface/_zope_interface_coptimizations.c',
         ],
         extra_compile_args=common_cflags,
     ),
     Extension(
         'mercurial.thirdparty.sha1dc',
         [
             'mercurial/thirdparty/sha1dc/cext.c',
             'mercurial/thirdparty/sha1dc/lib/sha1.c',
             'mercurial/thirdparty/sha1dc/lib/ubc_check.c',
         ],
         extra_compile_args=common_cflags,
     ),
     Extension(
         'hgext.fsmonitor.pywatchman.bser',
         ['hgext/fsmonitor/pywatchman/bser.c'],
         extra_compile_args=common_cflags,
     ),
     RustStandaloneExtension(
         'mercurial.rustext',
         'hg-cpython',
         'librusthg',
     ),
 ]
 
 
 sys.path.insert(0, 'contrib/python-zstandard')
 import setup_zstd
 
 zstd = setup_zstd.get_c_extension(
     name='mercurial.zstd', root=os.path.abspath(os.path.dirname(__file__))
 )
 zstd.extra_compile_args += common_cflags
 extmodules.append(zstd)
 
 try:
     from distutils import cygwinccompiler
 
     # the -mno-cygwin option has been deprecated for years
     mingw32compilerclass = cygwinccompiler.Mingw32CCompiler
 
     class HackedMingw32CCompiler(cygwinccompiler.Mingw32CCompiler):
         def __init__(self, *args, **kwargs):
             mingw32compilerclass.__init__(self, *args, **kwargs)
             for i in 'compiler compiler_so linker_exe linker_so'.split():
                 try:
                     getattr(self, i).remove('-mno-cygwin')
                 except ValueError:
                     pass
 
     cygwinccompiler.Mingw32CCompiler = HackedMingw32CCompiler
 except ImportError:
     # the cygwinccompiler package is not available on some Python
     # distributions like the ones from the optware project for Synology
     # DiskStation boxes
     class HackedMingw32CCompiler:
         pass
 
 
 if os.name == 'nt':
     # Allow compiler/linker flags to be added to Visual Studio builds.  Passing
     # extra_link_args to distutils.extensions.Extension() doesn't have any
     # effect.
     from distutils import msvccompiler
 
     msvccompilerclass = msvccompiler.MSVCCompiler
 
     class HackedMSVCCompiler(msvccompiler.MSVCCompiler):
         def initialize(self):
             msvccompilerclass.initialize(self)
             # "warning LNK4197: export 'func' specified multiple times"
             self.ldflags_shared.append('/ignore:4197')
             self.ldflags_shared_debug.append('/ignore:4197')
 
     msvccompiler.MSVCCompiler = HackedMSVCCompiler
 
 packagedata = {
     'mercurial': [
         'locale/*/LC_MESSAGES/hg.mo',
         'dummycert.pem',
     ],
     'mercurial.defaultrc': [
         '*.rc',
     ],
     'mercurial.helptext': [
         '*.txt',
     ],
     'mercurial.helptext.internals': [
         '*.txt',
     ],
 }
 
 
 def ordinarypath(p):
     return p and p[0] != '.' and p[-1] != '~'
 
 
 for root in ('templates',):
     for curdir, dirs, files in os.walk(os.path.join('mercurial', root)):
         packagename = curdir.replace(os.sep, '.')
         packagedata[packagename] = list(filter(ordinarypath, files))
 
 datafiles = []
 
 # distutils expects version to be str/unicode. Converting it to
 # unicode on Python 2 still works because it won't contain any
 # non-ascii bytes and will be implicitly converted back to bytes
 # when operated on.
 assert isinstance(version, str)
 setupversion = version
 
 extra = {}
 
 py2exepackages = [
     'hgdemandimport',
     'hgext3rd',
     'hgext',
     'email',
     # implicitly imported per module policy
     # (cffi wouldn't be used as a frozen exe)
     'mercurial.cext',
     #'mercurial.cffi',
     'mercurial.pure',
 ]
 
 py2exe_includes = []
 
 py2exeexcludes = []
 py2exedllexcludes = ['crypt32.dll']
 
 if issetuptools:
     extra['python_requires'] = supportedpy
 
 if py2exeloaded:
     extra['console'] = [
         {
             'script': 'hg',
             'copyright': 'Copyright (C) 2005-2022 Olivia Mackall and others',
             'product_version': version,
         }
     ]
     # Sub command of 'build' because 'py2exe' does not handle sub_commands.
     # Need to override hgbuild because it has a private copy of
     # build.sub_commands.
     hgbuild.sub_commands.insert(0, ('build_hgextindex', None))
     # put dlls in sub directory so that they won't pollute PATH
     extra['zipfile'] = 'lib/library.zip'
 
     # We allow some configuration to be supplemented via environment
     # variables. This is better than setup.cfg files because it allows
     # supplementing configs instead of replacing them.
     extrapackages = os.environ.get('HG_PY2EXE_EXTRA_PACKAGES')
     if extrapackages:
         py2exepackages.extend(extrapackages.split(' '))
 
     extra_includes = os.environ.get('HG_PY2EXE_EXTRA_INCLUDES')
     if extra_includes:
         py2exe_includes.extend(extra_includes.split(' '))
 
     excludes = os.environ.get('HG_PY2EXE_EXTRA_EXCLUDES')
     if excludes:
         py2exeexcludes.extend(excludes.split(' '))
 
     dllexcludes = os.environ.get('HG_PY2EXE_EXTRA_DLL_EXCLUDES')
     if dllexcludes:
         py2exedllexcludes.extend(dllexcludes.split(' '))
 
 if os.environ.get('PYOXIDIZER'):
     hgbuild.sub_commands.insert(0, ('build_hgextindex', None))
 
 if os.name == 'nt':
     # Windows binary file versions for exe/dll files must have the
     # form W.X.Y.Z, where W,X,Y,Z are numbers in the range 0..65535
     setupversion = setupversion.split(r'+', 1)[0]
 
 if sys.platform == 'darwin' and os.path.exists('/usr/bin/xcodebuild'):
     version = runcmd(['/usr/bin/xcodebuild', '-version'], {})[1].splitlines()
     if version:
         version = version[0].decode('utf-8')
         xcode4 = version.startswith('Xcode') and StrictVersion(
             version.split()[1]
         ) >= StrictVersion('4.0')
         xcode51 = re.match(r'^Xcode\s+5\.1', version) is not None
     else:
         # xcodebuild returns empty on OS X Lion with XCode 4.3 not
         # installed, but instead with only command-line tools. Assume
         # that only happens on >= Lion, thus no PPC support.
         xcode4 = True
         xcode51 = False
 
     # XCode 4.0 dropped support for ppc architecture, which is hardcoded in
     # distutils.sysconfig
     if xcode4:
         os.environ['ARCHFLAGS'] = ''
 
     # XCode 5.1 changes clang such that it now fails to compile if the
     # -mno-fused-madd flag is passed, but the version of Python shipped with
     # OS X 10.9 Mavericks includes this flag. This causes problems in all
     # C extension modules, and a bug has been filed upstream at
     # http://bugs.python.org/issue21244. We also need to patch this here
     # so Mercurial can continue to compile in the meantime.
     if xcode51:
         cflags = get_config_var('CFLAGS')
         if cflags and re.search(r'-mno-fused-madd\b', cflags) is not None:
             os.environ['CFLAGS'] = (
                 os.environ.get('CFLAGS', '') + ' -Qunused-arguments'
             )
 
 setup(
     name='mercurial',
     version=setupversion,
     author='Olivia Mackall and many others',
     author_email='[e-mail]',
     url='https://mercurial-scm.org/',
     download_url='https://mercurial-scm.org/release/',
     description=(
         'Fast scalable distributed SCM (revision control, version '
         'control) system'
     ),
     long_description=(
         'Mercurial is a distributed SCM tool written in Python.'
         ' It is used by a number of large projects that require'
         ' fast, reliable distributed revision control, such as '
         'Mozilla.'
     ),
     license='GNU GPLv2 or any later version',
     classifiers=[
         'Development Status :: 6 - Mature',
         'Environment :: Console',
         'Intended Audience :: Developers',
         'Intended Audience :: System Administrators',
         'License :: OSI Approved :: GNU General Public License (GPL)',
         'Natural Language :: Danish',
         'Natural Language :: English',
         'Natural Language :: German',
         'Natural Language :: Italian',
         'Natural Language :: Japanese',
         'Natural Language :: Portuguese (Brazilian)',
         'Operating System :: Microsoft :: Windows',
         'Operating System :: OS Independent',
         'Operating System :: POSIX',
         'Programming Language :: C',
         'Programming Language :: Python',
         'Topic :: Software Development :: Version Control',
     ],
     scripts=scripts,
     packages=packages,
     ext_modules=extmodules,
     data_files=datafiles,
     package_data=packagedata,
     cmdclass=cmdclass,
     distclass=hgdist,
     options={
         'py2exe': {
             'bundle_files': 3,
             'dll_excludes': py2exedllexcludes,
             'includes': py2exe_includes,
             'excludes': py2exeexcludes,
             'packages': py2exepackages,
         },
         'bdist_mpkg': {
             'zipdist': False,
             'license': 'COPYING',
             'readme': 'contrib/packaging/macosx/Readme.html',
             'welcome': 'contrib/packaging/macosx/Welcome.html',
         },
     },
     **extra
 )

tests/test-mac-packages.t

@@ -1,71 +1,71 b''
 #require test-repo slow osx osxpackaging
 
   $ . "$TESTDIR/helpers-testrepo.sh"
   $ testrepohgenv
 
   $ OUTPUTDIR="`pwd`"
   $ export OUTPUTDIR
   $ KEEPMPKG=yes
   $ export KEEPMPKG
 
   $ cd "$TESTDIR"/..
   $ contrib/genosxversion.py --selftest ignoredarg
   $ make osx > "$OUTPUTDIR/build.log" 2>&1
   $ cd "$OUTPUTDIR"
   $ ls -d *.pkg
   Mercurial-*-macosx10.*.pkg (glob)
 
   $ xar -xf Mercurial*.pkg
 
 Gather list of all installed files:
   $ lsbom mercurial.pkg/Bom > boms.txt
 
 We've had problems with the filter logic in the past. Make sure no
 .DS_Store files ended up in the final package:
   $ grep DS_S boms.txt
   [1]
 
 Spot-check some randomly selected files:
   $ grep bdiff boms.txt | cut -d '	' -f 1,2,3
   ./Library/Python/2.7/site-packages/mercurial/cext/bdiff.so	100755	0/0
   ./Library/Python/2.7/site-packages/mercurial/cffi/bdiff.py	100644	0/0
   ./Library/Python/2.7/site-packages/mercurial/cffi/bdiff.pyc	100644	0/0
   ./Library/Python/2.7/site-packages/mercurial/cffi/bdiff.pyo	100644	0/0
   ./Library/Python/2.7/site-packages/mercurial/cffi/bdiffbuild.py	100644	0/0
   ./Library/Python/2.7/site-packages/mercurial/cffi/bdiffbuild.pyc	100644	0/0
   ./Library/Python/2.7/site-packages/mercurial/cffi/bdiffbuild.pyo	100644	0/0
   ./Library/Python/2.7/site-packages/mercurial/pure/bdiff.py	100644	0/0
   ./Library/Python/2.7/site-packages/mercurial/pure/bdiff.pyc	100644	0/0
   ./Library/Python/2.7/site-packages/mercurial/pure/bdiff.pyo	100644	0/0
   $ grep zsh/site-functions/_hg boms.txt | cut -d '	' -f 1,2,3
   ./usr/local/share/zsh/site-functions/_hg	100644	0/0
-  $ grep hg-completion.bash boms.txt | cut -d '	' -f 1,2,3
-  ./usr/local/hg/contrib/hg-completion.bash	100644	0/0
+  $ grep bash-completion/completions/hg boms.txt | cut -d '	' -f 1,2,3
+  ./usr/local/share/bash-completion-completions/hg	100644	0/0
   $ egrep 'man[15]' boms.txt | cut -d '	' -f 1,2,3
   ./usr/local/share/man/man1	40755	0/0
   ./usr/local/share/man/man1/chg.1	100644	0/0
   ./usr/local/share/man/man1/hg.1	100644	0/0
   ./usr/local/share/man/man5	40755	0/0
   ./usr/local/share/man/man5/hgignore.5	100644	0/0
   ./usr/local/share/man/man5/hgrc.5	100644	0/0
   $ grep bser boms.txt | cut -d '	' -f 1,2,3
   ./Library/Python/2.7/site-packages/hgext/fsmonitor/pywatchman/bser.so	100755	0/0
   ./Library/Python/2.7/site-packages/hgext/fsmonitor/pywatchman/pybser.py	100644	0/0
   ./Library/Python/2.7/site-packages/hgext/fsmonitor/pywatchman/pybser.pyc	100644	0/0
   ./Library/Python/2.7/site-packages/hgext/fsmonitor/pywatchman/pybser.pyo	100644	0/0
   $ grep localrepo boms.txt | cut -d '	' -f 1,2,3
   ./Library/Python/2.7/site-packages/mercurial/localrepo.py	100644	0/0
   ./Library/Python/2.7/site-packages/mercurial/localrepo.pyc	100644	0/0
   ./Library/Python/2.7/site-packages/mercurial/localrepo.pyo	100644	0/0
   $ egrep 'bin/' boms.txt | cut -d '	' -f 1,2,3
   ./usr/local/bin/chg	100755	0/0
   ./usr/local/bin/hg	100755	0/0
 
 Make sure the built binary uses the system Python interpreter
   $ bsdtar xf mercurial.pkg/Payload usr/local/bin
 Use a glob to find this to avoid check-code whining about a fixed path.
   $ head -n 1 usr/local/b?n/hg
   #!/System/Library/Frameworks/Python.framework/Versions/2.7/Resources/Python.app/Contents/MacOS/Python
 
 Note that we're not currently installing any /etc/mercurial stuff,
 including merge-tool configurations.