macos-ci.yml

name: macOS CI

on:
  push:
    branches: [ main, develop ]
  pull_request:
    branches: [ main, develop ]
  workflow_dispatch:

jobs:
  build-and-test:
    runs-on: macos-15

    env:
      SWIFT_VERSION: swift-DEVELOPMENT-SNAPSHOT-2025-10-02-a
      PYTORCH_VERSION: v2.8.0
      PYTORCH_INSTALL_DIR: ${{ github.workspace }}/pytorch-install
      CC: clang
      CXX: clang++

    steps:
    - name: Checkout repository
      uses: actions/checkout@v4

    - name: Install Xcode Command Line Tools
      run: |
        # Check if command line tools are already installed
        if ! xcode-select -p &> /dev/null; then
          echo "Installing Xcode Command Line Tools..."
          xcode-select --install
          # Wait for installation to complete
          until xcode-select -p &> /dev/null; do
            sleep 5
          done
        else
          echo "Xcode Command Line Tools already installed at: $(xcode-select -p)"
        fi
        # Accept license if needed
        sudo xcodebuild -license accept 2>/dev/null || true

    - name: Install Homebrew dependencies
      run: |
        brew update
        brew install \
          cmake \
          ninja \
          libomp \
          openblas \
          protobuf \
          wget \
          gnu-getopt

    - name: Install Python packages for PyTorch
      run: |
        pip3 install --break-system-packages \
          numpy \
          pyyaml \
          typing_extensions \
          sympy \
          cffi \
          cmake

    - name: Cache Swift toolchain
      id: cache-swift
      uses: actions/cache@v4
      with:
        path: |
          ~/Library/Developer/Toolchains/swift-DEVELOPMENT-SNAPSHOT-2025-10-02-a.xctoolchain
        key: swift-toolchain-${{ runner.os }}-${{ env.SWIFT_VERSION }}

    - name: Install Swift via Swiftly
      if: steps.cache-swift.outputs.cache-hit != 'true'
      run: |
        export PATH="$(brew --prefix gnu-getopt)/bin:$PATH"
        curl -O https://download.swift.org/swiftly/darwin/swiftly.pkg
        installer -pkg swiftly.pkg -target CurrentUserHomeDirectory
        ~/.swiftly/bin/swiftly init --quiet-shell-followup
        . "${SWIFTLY_HOME_DIR:-$HOME/.swiftly}/env.sh"
        hash -r
        swiftly install ${SWIFT_VERSION} --assume-yes --use
        . "${SWIFTLY_HOME_DIR:-$HOME/.swiftly}/env.sh"
        hash -r
        rm swiftly.pkg
        echo "✅ Swift ${SWIFT_VERSION} installed successfully"
        swift --version

    - name: Set up Swift environment
      run: |
        # Set the toolchain path
        SWIFT_TOOLCHAIN_PATH="$HOME/Library/Developer/Toolchains/${SWIFT_VERSION}.xctoolchain"

        if [ ! -d "$SWIFT_TOOLCHAIN_PATH" ]; then
          echo "❌ Error: Swift toolchain not found at $SWIFT_TOOLCHAIN_PATH"
          echo "Available toolchains:"
          ls -la "$HOME/Library/Developer/Toolchains/" || echo "No toolchains directory"
          exit 1
        fi

        SWIFT_TOOLCHAIN_DIR="${SWIFT_TOOLCHAIN_PATH}/usr"
        SWIFT_BIN_DIR="${SWIFT_TOOLCHAIN_DIR}/bin"
        SWIFT_BIN="${SWIFT_BIN_DIR}/swift"

        # Add to PATH and environment
        echo "${SWIFT_BIN_DIR}" >> $GITHUB_PATH
        echo "SWIFT_TOOLCHAIN_DIR=${SWIFT_TOOLCHAIN_DIR}" >> $GITHUB_ENV
        echo "SWIFT_TOOLCHAIN_PATH=${SWIFT_TOOLCHAIN_PATH}" >> $GITHUB_ENV
        echo "SWIFT_TOOLCHAIN=${SWIFT_TOOLCHAIN_PATH}" >> $GITHUB_ENV
        echo "SWIFTPM_SWIFT_EXEC=${SWIFT_BIN}" >> $GITHUB_ENV

        # Verify Swift version
        echo "✅ Swift environment configured:"
        "${SWIFT_BIN}" --version

    - name: Select Swift toolchain
      run: |
        SWIFT_TOOLCHAIN_PATH="${SWIFT_TOOLCHAIN_PATH:-}"
        if [ -z "$SWIFT_TOOLCHAIN_PATH" ]; then
          echo "Error: Swift toolchain path not resolved"
          exit 1
        fi
        if [ ! -d "$SWIFT_TOOLCHAIN_PATH" ]; then
          echo "Error: Swift toolchain not found at $SWIFT_TOOLCHAIN_PATH"
          exit 1
        fi

        # Get the toolchain identifier from Info.plist
        TOOLCHAIN_INFO_PLIST="${SWIFT_TOOLCHAIN_PATH}/Info.plist"
        if [ -f "$TOOLCHAIN_INFO_PLIST" ]; then
          TOOLCHAIN_IDENTIFIER=$(/usr/libexec/PlistBuddy -c "Print :CFBundleIdentifier" "$TOOLCHAIN_INFO_PLIST" 2>/dev/null || echo "")
          if [ -z "$TOOLCHAIN_IDENTIFIER" ]; then
            # Fallback: try to extract from filename
            TOOLCHAIN_IDENTIFIER="org.swift.$(echo ${SWIFT_VERSION} | sed 's/swift-DEVELOPMENT-SNAPSHOT-//' | sed 's/-a$//' | tr -d '-')"
          fi
        else
          # Fallback identifier
          TOOLCHAIN_IDENTIFIER="swift"
        fi

        # Set SDKROOT to point to macOS SDK (needed for C/C++ compilation)
        SDKROOT=$(xcrun --sdk macosx --show-sdk-path)
        echo "SDKROOT=${SDKROOT}" >> $GITHUB_ENV
        if [ -n "$LIBRARY_PATH" ]; then
          echo "LIBRARY_PATH=${SDKROOT}/usr/lib:${LIBRARY_PATH}" >> $GITHUB_ENV
        else
          echo "LIBRARY_PATH=${SDKROOT}/usr/lib" >> $GITHUB_ENV
        fi
        echo "SDK root: $SDKROOT"

        # Verify the SDK has essential headers
        if [ -f "${SDKROOT}/usr/include/tgmath.h" ]; then
          echo "✓ Found tgmath.h at ${SDKROOT}/usr/include/tgmath.h"
        else
          echo "✗ WARNING: tgmath.h not found - SDK may be incomplete!"
          echo "This may cause compilation errors with PyTorch or Swift C++ interop"
        fi

        DARWIN_MODULEMAP="${SDKROOT}/usr/include/module.modulemap"
        if [ -f "$DARWIN_MODULEMAP" ]; then
          echo "✓ Found module.modulemap at $DARWIN_MODULEMAP"
        else
          ALT_DARWIN=$(find "${SDKROOT}/usr/include" -name "module.modulemap" -print -quit 2>/dev/null || true)
          if [ -z "$ALT_DARWIN" ]; then
            ALT_DARWIN=$(find "${SWIFT_TOOLCHAIN_PATH}/usr/lib/swift/clang/include" -name "module.modulemap" -print -quit 2>/dev/null || true)
          fi
          if [ -n "$ALT_DARWIN" ] && [ -f "$ALT_DARWIN" ]; then
            DARWIN_MODULEMAP="$ALT_DARWIN"
            echo "✓ Found module.modulemap at $DARWIN_MODULEMAP"
          else
            echo "✗ WARNING: module.modulemap not found in SDK or Swift toolchain"
            DARWIN_MODULEMAP=""
          fi
        fi

        C_STD_MODULEMAP="${SDKROOT}/usr/include/c_standard_library.modulemap"
        if [ -f "$C_STD_MODULEMAP" ]; then
          echo "✓ Found c_standard_library.modulemap at $C_STD_MODULEMAP"
        else
          ALT_C_STD=$(find "${SDKROOT}/usr/include" -name "c_standard_library.modulemap" -print -quit 2>/dev/null || true)
          if [ -z "$ALT_C_STD" ]; then
            ALT_C_STD=$(find "${SWIFT_TOOLCHAIN_PATH}/usr/lib/swift/clang/include" -name "c_standard_library.modulemap" -print -quit 2>/dev/null || true)
          fi
          if [ -n "$ALT_C_STD" ] && [ -f "$ALT_C_STD" ]; then
            C_STD_MODULEMAP="$ALT_C_STD"
            echo "✓ Found c_standard_library.modulemap at $C_STD_MODULEMAP"
          else
            echo "✗ WARNING: c_standard_library.modulemap not found in SDK or Swift toolchain"
            C_STD_MODULEMAP=""
          fi
        fi

        echo "DARWIN_MODULEMAP=${DARWIN_MODULEMAP}" >> $GITHUB_ENV
        echo "C_STANDARD_LIBRARY_MODULEMAP=${C_STD_MODULEMAP}" >> $GITHUB_ENV

        echo "SWIFT_TOOLCHAIN_DIR=${SWIFT_TOOLCHAIN_PATH}/usr" >> $GITHUB_ENV
        echo "SWIFT_TOOLCHAIN_PATH=${SWIFT_TOOLCHAIN_PATH}" >> $GITHUB_ENV
        echo "SWIFT_TOOLCHAIN=${SWIFT_TOOLCHAIN_PATH}" >> $GITHUB_ENV
        echo "SWIFTPM_SWIFT_EXEC=${SWIFT_TOOLCHAIN_PATH}/usr/bin/swift" >> $GITHUB_ENV
        echo "TOOLCHAINS=${TOOLCHAIN_IDENTIFIER}" >> $GITHUB_ENV
        echo "${SWIFT_TOOLCHAIN_PATH}/usr/bin" >> $GITHUB_PATH

        # Verify clang exists
        if [ ! -f "${SWIFT_TOOLCHAIN_PATH}/usr/bin/clang" ]; then
          echo "Error: clang not found at ${SWIFT_TOOLCHAIN_PATH}/usr/bin/clang"
          exit 1
        fi

        echo "Swift toolchain path: $SWIFT_TOOLCHAIN_PATH"
        echo "Toolchain identifier: $TOOLCHAIN_IDENTIFIER"
        echo "Clang path: ${SWIFT_TOOLCHAIN_PATH}/usr/bin/clang"
        echo "Swift binary: ${SWIFT_TOOLCHAIN_PATH}/usr/bin/swift"

        # Set TOOLCHAINS for this step and verify
        export TOOLCHAINS="${TOOLCHAIN_IDENTIFIER}"
        swift --version

    - name: Cache PyTorch build
      id: cache-pytorch
      uses: actions/cache@v4
      with:
        path: ${{ github.workspace }}/pytorch-install
        key: pytorch-${{ env.PYTORCH_VERSION }}-macos-clang-${{ hashFiles('.github/workflows/macos-ci.yml') }}

    - name: Clone PyTorch
      if: steps.cache-pytorch.outputs.cache-hit != 'true'
      run: |
        git clone --recursive https://github.com/pytorch/pytorch.git ${{ github.workspace }}/pytorch-src
        cd ${{ github.workspace }}/pytorch-src
        git checkout ${PYTORCH_VERSION}
        git submodule sync
        git submodule update --init --recursive

    - name: Build PyTorch
      if: steps.cache-pytorch.outputs.cache-hit != 'true'
      run: |
        # Verify SWIFT_TOOLCHAIN_DIR is set
        if [ -z "$SWIFT_TOOLCHAIN_DIR" ]; then
          echo "Error: SWIFT_TOOLCHAIN_DIR is not set"
          exit 1
        fi

        echo "SWIFT_TOOLCHAIN_DIR: $SWIFT_TOOLCHAIN_DIR"

        # Use Swift toolchain's clang
        SWIFT_CLANG="${SWIFT_TOOLCHAIN_DIR}/bin/clang"
        SWIFT_CLANGXX="${SWIFT_TOOLCHAIN_DIR}/bin/clang++"

        # Verify compilers exist
        if [ ! -f "$SWIFT_CLANG" ]; then
          echo "Error: clang not found at $SWIFT_CLANG"
          exit 1
        fi
        if [ ! -f "$SWIFT_CLANGXX" ]; then
          echo "Error: clang++ not found at $SWIFT_CLANGXX"
          exit 1
        fi

        echo "Using clang: $SWIFT_CLANG"
        echo "Using clang++: $SWIFT_CLANGXX"

        cd ${{ github.workspace }}/pytorch-src
        mkdir -p build
        cd build

        CC=$SWIFT_CLANG CXX=$SWIFT_CLANGXX cmake .. \
          -DCMAKE_C_COMPILER=$SWIFT_CLANG \
          -DCMAKE_CXX_COMPILER=$SWIFT_CLANGXX \
          -DBUILD_SHARED_LIBS=ON \
          -DCMAKE_BUILD_TYPE=Release \
          -DCMAKE_INSTALL_PREFIX=${{ github.workspace }}/pytorch-install \
          -DBUILD_PYTHON=OFF \
          -DBUILD_TEST=OFF \
          -DBUILD_CAFFE2=OFF \
          -DUSE_DISTRIBUTED=OFF \
          -DUSE_MPS=OFF \
          -DUSE_CUDA=OFF \
          -DPYTHON_EXECUTABLE=$(which python3) \
          -GNinja
        cmake --build . --target install -j$(sysctl -n hw.ncpu)

    - name: Set up environment
      run: |
        echo "PYTORCH_INSTALL_DIR=${{ github.workspace }}/pytorch-install" >> $GITHUB_ENV
        echo "DYLD_LIBRARY_PATH=${{ github.workspace }}/pytorch-install/lib:$DYLD_LIBRARY_PATH" >> $GITHUB_ENV

    - name: Verify Swift and PyTorch setup
      run: |
        echo "Swift version:"
        swift --version
        echo "Swift toolchain dir: $SWIFT_TOOLCHAIN_DIR"
        echo "PyTorch install dir: $PYTORCH_INSTALL_DIR"
        echo "SDKROOT: $SDKROOT"
        echo "TOOLCHAINS: $TOOLCHAINS"
        echo "Checking PyTorch libraries:"
        ls -la $PYTORCH_INSTALL_DIR/lib/ | head -20

        # Verify SDKROOT is set and tgmath.h exists
        if [ -z "$SDKROOT" ]; then
          echo "ERROR: SDKROOT is not set!"
          echo "Setting SDKROOT now..."
          SDKROOT=$(xcrun --sdk macosx --show-sdk-path)
          echo "SDKROOT=${SDKROOT}" >> $GITHUB_ENV
        fi

        if [ ! -f "${SDKROOT}/usr/include/tgmath.h" ]; then
          echo "ERROR: tgmath.h not found at ${SDKROOT}/usr/include/tgmath.h"
          echo "SDK path: $SDKROOT"
          echo "Contents of SDK include dir:"
          ls -la "${SDKROOT}/usr/include/" | head -20
          exit 1
        else
          echo "✓ tgmath.h found at ${SDKROOT}/usr/include/tgmath.h"
        fi

    - name: Build TaylorTorch
      run: |
        # Get SDKROOT dynamically
        SDKROOT=$(xcrun --sdk macosx --show-sdk-path)

        echo "Building with:"
        echo "  SDKROOT: $SDKROOT"
        echo "  TOOLCHAINS: $TOOLCHAINS"
        echo "  SWIFT_TOOLCHAIN_DIR: $SWIFT_TOOLCHAIN_DIR"

        # Verify tgmath.h exists before building
        if [ ! -f "${SDKROOT}/usr/include/tgmath.h" ]; then
          echo "ERROR: tgmath.h not found at ${SDKROOT}/usr/include/tgmath.h"
          exit 1
        fi

        # Build with explicit SDK and toolchain flags
        export SDKROOT="${SDKROOT}"
        export TOOLCHAINS="${TOOLCHAINS}"
        export CPATH="${SDKROOT}/usr/include"
        DARWIN_MODULEMAP=${DARWIN_MODULEMAP:-${SDKROOT}/usr/include/module.modulemap}
        C_STANDARD_LIBRARY_MODULEMAP=${C_STANDARD_LIBRARY_MODULEMAP:-${SDKROOT}/usr/include/c_standard_library.modulemap}
        export DARWIN_MODULEMAP
        export C_STANDARD_LIBRARY_MODULEMAP

        MODULEMAP_FLAGS=()
        if [ -n "${DARWIN_MODULEMAP:-}" ] && [ -f "$DARWIN_MODULEMAP" ]; then
          MODULEMAP_FLAGS+=(-Xcc "-fmodule-map-file=${DARWIN_MODULEMAP}")
        else
          echo "WARNING: DARWIN_MODULEMAP not set or missing (${DARWIN_MODULEMAP:-unset}); continuing without explicit module.modulemap."
        fi
        if [ -n "${C_STANDARD_LIBRARY_MODULEMAP:-}" ] && [ -f "$C_STANDARD_LIBRARY_MODULEMAP" ]; then
          MODULEMAP_FLAGS+=(-Xcc "-fmodule-map-file=${C_STANDARD_LIBRARY_MODULEMAP}")
        else
          echo "WARNING: C_STANDARD_LIBRARY_MODULEMAP not set or missing (${C_STANDARD_LIBRARY_MODULEMAP:-unset}); continuing without explicit c_standard_library.modulemap."
        fi

        swift build -c release \
          -Xswiftc -sdk -Xswiftc "${SDKROOT}" \
          -Xcc -isysroot -Xcc "${SDKROOT}" \
          "${MODULEMAP_FLAGS[@]}" \
          -Xlinker -L -Xlinker "${SDKROOT}/usr/lib" \
          -v

    - name: Run tests
      run: |
        SDKROOT=$(xcrun --sdk macosx --show-sdk-path)
        export SDKROOT="${SDKROOT}"
        export TOOLCHAINS="${TOOLCHAINS}"
        export CPATH="${SDKROOT}/usr/include"
        DARWIN_MODULEMAP=${DARWIN_MODULEMAP:-${SDKROOT}/usr/include/module.modulemap}
        C_STANDARD_LIBRARY_MODULEMAP=${C_STANDARD_LIBRARY_MODULEMAP:-${SDKROOT}/usr/include/c_standard_library.modulemap}
        export DARWIN_MODULEMAP
        export C_STANDARD_LIBRARY_MODULEMAP

        MODULEMAP_FLAGS=()
        if [ -n "${DARWIN_MODULEMAP:-}" ] && [ -f "$DARWIN_MODULEMAP" ]; then
          MODULEMAP_FLAGS+=(-Xcc "-fmodule-map-file=${DARWIN_MODULEMAP}")
        else
          echo "WARNING: DARWIN_MODULEMAP not set or missing (${DARWIN_MODULEMAP:-unset}); continuing without explicit module.modulemap."
        fi
        if [ -n "${C_STANDARD_LIBRARY_MODULEMAP:-}" ] && [ -f "$C_STANDARD_LIBRARY_MODULEMAP" ]; then
          MODULEMAP_FLAGS+=(-Xcc "-fmodule-map-file=${C_STANDARD_LIBRARY_MODULEMAP}")
        else
          echo "WARNING: C_STANDARD_LIBRARY_MODULEMAP not set or missing (${C_STANDARD_LIBRARY_MODULEMAP:-unset}); continuing without explicit c_standard_library.modulemap."
        fi

        swift test -c release \
          -Xswiftc -sdk -Xswiftc "${SDKROOT}" \
          -Xcc -isysroot -Xcc "${SDKROOT}" \
          "${MODULEMAP_FLAGS[@]}" \
          -Xlinker -L -Xlinker "${SDKROOT}/usr/lib"

    - name: Build examples
      run: |
        SDKROOT=$(xcrun --sdk macosx --show-sdk-path)
        export SDKROOT="${SDKROOT}"
        export TOOLCHAINS="${TOOLCHAINS}"
        export CPATH="${SDKROOT}/usr/include"
        DARWIN_MODULEMAP=${DARWIN_MODULEMAP:-${SDKROOT}/usr/include/module.modulemap}
        C_STANDARD_LIBRARY_MODULEMAP=${C_STANDARD_LIBRARY_MODULEMAP:-${SDKROOT}/usr/include/c_standard_library.modulemap}
        export DARWIN_MODULEMAP
        export C_STANDARD_LIBRARY_MODULEMAP

        MODULEMAP_FLAGS=()
        if [ -n "${DARWIN_MODULEMAP:-}" ] && [ -f "$DARWIN_MODULEMAP" ]; then
          MODULEMAP_FLAGS+=(-Xcc "-fmodule-map-file=${DARWIN_MODULEMAP}")
        else
          echo "WARNING: DARWIN_MODULEMAP not set or missing (${DARWIN_MODULEMAP:-unset}); continuing without explicit module.modulemap."
        fi
        if [ -n "${C_STANDARD_LIBRARY_MODULEMAP:-}" ] && [ -f "$C_STANDARD_LIBRARY_MODULEMAP" ]; then
          MODULEMAP_FLAGS+=(-Xcc "-fmodule-map-file=${C_STANDARD_LIBRARY_MODULEMAP}")
        else
          echo "WARNING: C_STANDARD_LIBRARY_MODULEMAP not set or missing (${C_STANDARD_LIBRARY_MODULEMAP:-unset}); continuing without explicit c_standard_library.modulemap."
        fi

        swift build -c release --product MNISTExample \
          -Xswiftc -sdk -Xswiftc "${SDKROOT}" \
          -Xcc -isysroot -Xcc "${SDKROOT}" \
          "${MODULEMAP_FLAGS[@]}" \
          -Xlinker -L -Xlinker "${SDKROOT}/usr/lib"
        swift build -c release --product ANKIExample \
          -Xswiftc -sdk -Xswiftc "${SDKROOT}" \
          -Xcc -isysroot -Xcc "${SDKROOT}" \
          "${MODULEMAP_FLAGS[@]}" \
          -Xlinker -L -Xlinker "${SDKROOT}/usr/lib"
        swift build -c release --product KARATEExample \
          -Xswiftc -sdk -Xswiftc "${SDKROOT}" \
          -Xcc -isysroot -Xcc "${SDKROOT}" \
          "${MODULEMAP_FLAGS[@]}" \
          -Xlinker -L -Xlinker "${SDKROOT}/usr/lib"