Future work to enable Android SDKs requires fetching additional
dependencies (e.g. Android NDK). Refactor the fetch dependencies method
to allow us to share the download logic rather than replicating it for
each piece. This will also allow us to fetch the Python dependency for
the ARM64 toolchain cross-compilation.
Introduce android and start wiring up the platform to additional sites.
While we cannot yet build the android SDK, this improves the summary to
use the platform identifier and sets up the ability to build android
variants.
Remove some hardcoded globals which assumed that builds were always for
the same OS. With the introduction of Android SDK support, we will no
longer be able to hold to that.
This is motivated by an experiment to build DocC with CMake which
exposed a bug in the Swift driver. This allows us to workaround that bug
with the Swift Swift driver.
Emit this in a `finally` block ensuring that it is printed at the end
under all circumstances. Reduce the column width by making the checkout
`SourceCache` relative.
`-Test swiftpm` will use the self-hosted build of SPM to run the test
suite. By using the `SWIFTCI_USE_LOCAL_DEPS=1` environment variable, we
do reduce some of the cost of this by not recloning the repositories,
but the entire dependency tree must be built a second time due to the
switch in the build system.
Use the new CMake options for controlling debug information generation.
This matches the recommendations from sccache and avoids us trying to
map flags manually.
When we build the standard library, we use the just built compilers.
However, we would not pass the necessary flags to the linker to generate
the debug information (PDBs) which would then make debugging more
challenging than it already is.
Use the installed image rather than the build tree for wiring up CMark.
This may be used across phases of the build, so it is better to use the
staged image.
We would use integral values to identify the target library rather than
using a named enumerator. Change to a named enumerator and inline some
cases where we would explain the code by creating variables.
This allows us to build swift-format with dynamic linking against the
toolchain build of the swift-syntax and swift-argument-parser packages.
Wire up the swift-markdown build and hoist the swift-format build prior
to sourcekit-lsp. This sets us up for supporting swift-format based
formatting in the LSP.
When the compiler changes, the SDK and tool builds do not notice the
compiler change due to the missing compiler tracking. This allows us to
quickly perform an incremental by not discarding the compiler build.
Extricate cmark from the unified build system. This is preparatory work
to support building CMark GFM with dynamic linkage for sharing it across
swift-markdown and the compiler. It also simplifies the build logic for
the unified build.
Re-use the existing `-InstallTo` option over the `CMAKE_INSTALL_PREFIX`
CMake parameter for building the targets. This cleans up the options
usage to use that mechanism. The intention is to minimise the custom
parameters to CMake in favour of a standard option handling.
Conditionalise the inclusion of directory paths. If the include
directory is empty, CMake will raise an error. This allows us to disable
larger portions of the Swift build to speed up some of the build tool
configuration phase and prepares for consuming CMark GFM as a CMake
project.
Add a directory creation path prior to downloading. In the case that the
build tree did not exist, we would fail to fetch the content. This
allows us to build on a fresh setup.
Centralise the downloading of dependencies. This merges the SDK,
toolchain, and WiX downloading. This is a small clean up and
preparatory work to enable fetching sccache as well to ease the caching
setup.
