visual_studio_base:

    name: Test Visual Studio (base)

    uses: ./.github/workflows/visual_studio.yaml

      vs_version: "2022"

  visual_studio_stage2:

    name: Test Visual Studio

    uses: ./.github/workflows/visual_studio.yaml

    needs:

      - visual_studio_base

    strategy:

      matrix:

        vs_version:

          - "2019"

          - "2022"

        arch:

          - x86_64

          - i686

          - aarch64

        rust:

          - "1.54.0"

        include:

          - arch: x86_64

            vs_version: 2022

            rust: stable

          - arch: x86_64

            vs_version: 2022

            rust: nightly

    with:

      vs_version: "${{ matrix.vs_version}}"

      rust: 1.54.0

      target_arch: "${{ matrix.arch}}"

  windows_ninja_cl:

    name: Test Windows Ninja MSVC

    runs-on: ${{ matrix.os }}

    needs:

      - visual_studio_base

          - windows-2022

        compiler:

          - cl

          - clang-cl

          - clang

          - os: windows-2022

            vs_version: vs-2022

            cmake: 3.22.6

          - rust: 1.54.0

          # Add variable mapping for ilammy/msvc-dev-cmd action

          - arch: x86_64

            msvc_dev_arch: amd64

          - arch: i686

            msvc_dev_arch: amd64_x86

          - arch: aarch64

            msvc_dev_arch: amd64_arm64

          # Not sure what parameters CMake needs when cross-compiling with clang-cl, so exclude for now

          - compiler: clang-cl

          - compiler: clang-cl

          - compiler: clang

          - compiler: clang

      - name: Install CMake

        uses: lukka/get-cmake@519de0c7b4812477d74976b2523a9417f552d126

        with:

          cmakeVersion: "${{ matrix.cmake }}"

          ninjaVersion: "~1.10.0"

      - name: Install Rust

        id: install_rust

        uses: dtolnay/rust-toolchain@master

          toolchain: ${{matrix.rust}}

          targets: ${{matrix.arch}}-pc-windows-msvc

      - name: Setup MSVC Development Environment

        uses: ilammy/msvc-dev-cmd@v1

        with:

          arch: ${{ matrix.msvc_dev_arch }}

      - name: Configure

        run: cmake -S. -Bbuild "-DRust_TOOLCHAIN=${{steps.install_rust.outputs.name}}" --preset "ninja-${{ matrix.arch }}-pc-windows-msvc-${{ matrix.compiler }}"

  windows_gnu:

    name: Test Windows GNU

    runs-on: ${{ matrix.os }}

    strategy:

      fail-fast: false

      matrix:

        os:

          - windows-2022

        arch:

          - x86_64

          # - i686

          # - aarch64

        compiler:

          - gcc # Clang only has experimental support for Cygwin / MinGW, so we don't test it

        generator:

          - ninja

          - make

        include:

          - cmake: 3.22.6

          - rust: 1.54.0

    steps:

      - uses: actions/checkout@v4

      - name: Install CMake

        uses: lukka/get-cmake@519de0c7b4812477d74976b2523a9417f552d126

        with:

          cmakeVersion: "${{ matrix.cmake }}"

          ninjaVersion: "~1.10.0"

      - name: Install Rust

        id: install_rust

        uses: dtolnay/rust-toolchain@master

        with:

          toolchain: ${{matrix.rust}}

          targets: ${{matrix.arch}}-pc-windows-gnu

      - name: Configure

        run: cmake -S. -Bbuild "-DRust_TOOLCHAIN=${{steps.install_rust.outputs.name}}" --preset "${{ matrix.generator }}-${{ matrix.arch }}-pc-windows-gnu-${{ matrix.compiler }}"

      - name: Run Tests

        working-directory: build

        run: ctest --output-on-failure --build-config Debug -j 3

  windows_gnullvm_msys2:

    name: Test Windows gnullvm on msys2

          # - i686

          # - aarch64

        generator:

          - Ninja

          - MSYS Makefiles

        include:

          - arch: x86_64

            msystem: CLANG64

#          - arch: i686

#            msystem: CLANG32

#          - arch: aarch64

#            msystem: CLANGARM64

    defaults:

      run:

        shell: msys2 {0}

    steps:

      - uses: actions/checkout@v4

      - name: Install Rust

        id: install_rust

        uses: dtolnay/rust-toolchain@master

        with:

          toolchain: stable

          targets: ${{matrix.arch}}-pc-windows-gnullvm

      - uses: msys2/setup-msys2@v2

        with:

          msystem: ${{matrix.msystem}}

          path-type: inherit

          install: >-

            git

            make

          pacboy: >-

            toolchain:p

            cmake:p

            ninja:p

      - name: Configure

        run: cmake -S. -Bbuild -G "${{matrix.generator}}" --toolchain=.github/scripts/toolchains/${{matrix.arch}}-pc-windows-gnullvm.cmake

      - name: Run Tests

        working-directory: build

        run: ctest --output-on-failure --build-config Debug -j 3

# For now just test if hostbuild works when cross-compiling on windows.

# For testing everything we would also need to install a cross-compiler first.

  windows_cross_hostbuild:

    name: Test Windows Cross

    runs-on: windows-2022

    steps:

      - uses: actions/checkout@v4

      - name: Install CMake

        uses: lukka/get-cmake@519de0c7b4812477d74976b2523a9417f552d126

        with:

          cmakeVersion: "~3.22.0"

          ninjaVersion: "~1.10.0"

      - name: Install Rust

        id: install_rust

        uses: dtolnay/rust-toolchain@master

        with:

          toolchain: stable

          targets: aarch64-unknown-linux-gnu

      - name: Configure

        run: cmake -S. -Bbuild "-DRust_TOOLCHAIN=${{steps.install_rust.outputs.name}}" -DRust_CARGO_TARGET=aarch64-unknown-linux-gnu

      - name: Run Tests

        working-directory: build

        run: ctest --output-on-failure --build-config Debug -R hostbuild

  linux_base:

    name: Test Linux (base)

    uses: ./.github/workflows/linux.yaml

    with:

      c_compiler: "gcc"

      generator: "Ninja"

  linux_stage2:

    name: Test Linux

    needs:

      - linux_base

    uses: ./.github/workflows/linux.yaml

    with:

      target_arch: "${{ matrix.arch }}"

      c_compiler: "${{ matrix.compiler }}"

      generator: "${{ matrix.generator }}"

    strategy:

      fail-fast: false

      matrix:

        arch:

          - x86_64

        compiler:

          - gcc

        generator:

          - "Ninja"

          - "Unix Makefiles"

          # rustc doesn't support cross-compiling with clang out of the box, since

          # clang requires a --target parameter. Corrosion currently can only pass

          # this for the top-level crate, so linking of cdylibs that are built as

          # dependencies of this crate will fail if they exist.

          # Solutions would be to make cross-compiling with clang work out-of-the-box

          # in rustc, or working around it in corrosion by adding a linker-wrapper.

          # For this reason we only test clang with the host target for now.

          - arch: x86_64

            compiler: clang

            generator: "Ninja"

            generator: "Ninja Multi-Config"

            compiler: gcc

  darwin:

    name: Test MacOS

    runs-on: ${{ matrix.os }}

    strategy:

      fail-fast: false

      matrix:

        arch:

          - x86_64

          - aarch64

        compiler:

          - clang

        generator:

          - "Ninja"

          - "Xcode"

        include:

          - os: macos-latest

          - cmake: 3.22.6

          - rust: 1.54.0

      - name: Install CMake

        uses: lukka/get-cmake@519de0c7b4812477d74976b2523a9417f552d126

          cmakeVersion: "${{ matrix.cmake }}"

          ninjaVersion: "~1.10.0"

      # Install cbindgen before Rust to use recent default Rust version.

      - name: Install cbindgen

        run: cargo install cbindgen

      - name: Install Rust

        id: install_rust

        uses: dtolnay/rust-toolchain@master

          toolchain: ${{matrix.rust}}

          targets: ${{matrix.arch}}-apple-darwin

      - name: Configure

        run: cmake -S. -Bbuild --log-level=DEBUG -G "${{ matrix.generator }}" "-DRust_TOOLCHAIN=${{steps.install_rust.outputs.name}}" --preset "${{ matrix.arch }}-apple-darwin-${{ matrix.compiler }}"

          - windows-2022

          - macos-13

          # Should be in sync with the `cxx` version the Carg.lock of the cxxbridge tests,

          # otherwise the caching will not work and the cmd will be built from source.

          - cxxbridge_version: "1.0.86"

          key: ${{ runner.os }}-cxxbridge_${{ matrix.cxxbridge_version }}

        run: cargo install cxxbridge-cmd@${{ matrix.cxxbridge_version }}

      - name: Setup MSVC Development Environment

        uses: ilammy/msvc-dev-cmd@v1

        if: runner.os == 'Windows'

      - name: Install CMake

        uses: lukka/get-cmake@519de0c7b4812477d74976b2523a9417f552d126

          cmakeVersion: "~3.22.0"

          ninjaVersion: "~1.10.0"

      - name: Install Rust

        uses: dtolnay/rust-toolchain@master

        with:

          toolchain: stable minus 2 releases

      - name: Configure

        run: >

          cmake

          -S.

          -Bbuild

          -GNinja

          -DCORROSION_VERBOSE_OUTPUT=ON

          -DCORROSION_TESTS_CXXBRIDGE=ON

  autoinstall_cargo_target:

    name: Test Auto-installing Cargo target via rustup

    runs-on: ubuntu-22.04

    steps:

      - uses: actions/checkout@v4

      - name: Install CMake

        uses: lukka/get-cmake@519de0c7b4812477d74976b2523a9417f552d126

      - name: Install Rust

        id: install_rust

        uses: dtolnay/rust-toolchain@stable

      - name: Install Cross Compiler

        shell: bash

        run: |

          echo "::group::apt-install"

          sudo apt-get update

          sudo apt-get install -y gcc-aarch64-linux-gnu

          echo "::endgroup::"

      - name: Assert rustup target is not installed

        run: rustup show | ( ! grep aarch64)

      - name: Configure Corrosion

        run: cmake -S. -Bbuild -GNinja -DRust_RUSTUP_INSTALL_MISSING_TARGET=ON --preset "aarch64-unknown-linux-gnu-gcc"

      - name: Check rustup target is installed after configuring

        run: rustup show | grep aarch64

          - windows-2022

          - macos-13

          - rust: 1.54.0

          cmakeVersion: "~3.22.0"

      # Install cbindgen before Rust to use recent default Rust version.

      - name: Install cbindgen

        run: cargo install cbindgen

  # We want an "accumulation" job here because it is easier to specify required

  # jobs here via needs, then in the github UI, since we use matrix jobs.

      - visual_studio_stage2

      - windows_ninja_cl

      - windows_gnu

      - windows_gnullvm_msys2

      - linux_stage2

      - darwin

      - autoinstall_cargo_target