open-standards/.github/workflows/wai-quantum-lang.yml

name: wai-quantum OpenQASM reader

# The OpenQASM reader every surface uses (wai/wai-quantum/src/qasm.rs and
# src/qasm/): its unit tests (the lexer, the parser, the elaborator, the
# diagnostic table and the page that documents it, every modifier against the
# matrix it must equal, every condition compiled to steps against every value
# of its bits), and the OpenQASM 3 conformance corpus
# (wai/quantum-conformance/qasm3/: the specification's example programs and a
# program for each construct, each with what the reader must do with it).
#
# The corpus runs natively, where a second test holds its bundle equal to its
# files, and under wasm32-wasip2 by wasmtime, where the cases come from the
# bundle the test compiles in. The browser build runs the corpus too
# (wai-web-wasm.yml, wai-web's wasm32 tests). The reader is also built without
# the lowerings (features quantum_lang and quantum_toolchain), as the edge
# component builds it.

concurrency:
  group: ${{ github.workflow }}-${{ github.event_name == 'push' && github.sha || github.ref }}
  cancel-in-progress: true

on:
  push:
    branches: [main]
    paths:
      - 'wai/wai-quantum/**'
      - 'wai/quantum-conformance/qasm3/**'
      - 'rust-toolchain.toml'
      - '.github/workflows/wai-quantum-lang.yml'
  pull_request:
    paths:
      - 'wai/wai-quantum/**'
      - 'wai/quantum-conformance/qasm3/**'
      - 'rust-toolchain.toml'
      - '.github/workflows/wai-quantum-lang.yml'

jobs:
  relevant:
    name: does this change touch it
    runs-on: gate
    outputs:
      run: ${{ steps.gate.outputs.run }}
    steps:
      - uses: actions/checkout@v5
        with:
          fetch-depth: 0
      - id: gate
        run: |
          set -euo pipefail
          r=$(python3 scripts/pr-touches-paths.py .github/workflows/wai-quantum-lang.yml \
                "${{ github.event.pull_request.base.sha }}" \
                "${{ github.event.pull_request.head.sha }}")
          echo "this change touches the OpenQASM reader: $r"
          echo "run=$r" >> "$GITHUB_OUTPUT"

  native:
    name: reader and corpus · linux
    needs: relevant
    if: needs.relevant.outputs.run == 'true'
    runs-on: linux
    timeout-minutes: 60
    steps:
      - uses: actions/checkout@v5
      - name: Install Rust 1.99.1
        shell: bash
        run: |
          export PATH="$HOME/.cargo/bin:$PATH"
          command -v rustup >/dev/null 2>&1 || \
            curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y --profile minimal --default-toolchain 1.99.1
          rustup toolchain install 1.99.1 --profile minimal
          rustup default 1.99.1
          echo "$HOME/.cargo/bin" >> "$GITHUB_PATH"
      # A module filter is satisfied by any one test of the module, so each
      # module's tests are required by name to have run.
      - name: The reader's unit tests
        shell: bash
        working-directory: wai/wai-quantum
        run: |
          set -euo pipefail
          cargo test --locked --release --features full --lib qasm 2>&1 | tee "$RUNNER_TEMP/qasm.log"
          grep -qE '^test result: ok\. [1-9][0-9]+ passed; 0 failed' "$RUNNER_TEMP/qasm.log" || { echo "::error::the reader's tests did not pass"; exit 1; }
          for m in qasm::diag qasm::lex qasm::parse qasm::value qasm::lang_tests qasm::whole_tests qasm::depth_tests qasm::spec_tests qasm::library qasm::tests quantum_toolchain::tests::qasm_round_trip; do
            grep -q "^test $m.* \.\.\. ok$" "$RUNNER_TEMP/qasm.log" || { echo "::error::no test of $m ran"; exit 1; }
          done
          # Each construct once read wrong, held to the specification, each test by name.
          for t in qasm::spec_tests::u_under_a_control_carries_its_global_phase \
                   qasm::spec_tests::u2_and_u3_under_a_control_carry_their_global_phase \
                   qasm::spec_tests::the_library_s_definitions_written_out_are_its_gates_under_control \
                   qasm::spec_tests::a_program_s_own_definition_of_a_built_in_name_is_the_gate_it_runs \
                   qasm::spec_tests::an_array_argument_is_a_reference \
                   qasm::spec_tests::an_angle_divided_by_an_angle_is_an_unsigned_integer \
                   qasm::spec_tests::a_float_to_an_angle_rounds_ties_to_even \
                   qasm::spec_tests::bitwise_operators_on_an_unsigned_integer_keep_to_its_width \
                   qasm::spec_tests::qelib1_s_gates_past_the_table_are_its_gates \
                   qasm::library::tests::every_gate_s_matrix_is_the_reader_s; do
            grep -q "^test $t \.\.\. ok$" "$RUNNER_TEMP/qasm.log" || { echo "::error::$t did not run and pass"; exit 1; }
          done
          # A gate held whole, each test by name.
          for t in qasm::whole_tests::a_whole_program_lowers_to_what_the_reader_writes \
                   qasm::whole_tests::every_program_of_the_reader_s_corpus_reads_alike_both_ways \
                   qasm::whole_tests::only_what_would_double_stands_whole \
                   qasm::whole_tests::past_what_standard_gates_hold_a_gate_still_reads_whole \
                   qasm::whole_tests::the_bit_exact_circuit_holds_a_whole_gate_under_its_controls \
                   qasm::whole_tests::the_whole_gate_is_nearer_the_ideal_state_than_its_expansion \
                   qasm::whole_tests::the_state_vector_of_a_whole_gate_is_its_expansion_s_within_rounding \
                   qasm::whole_tests::a_run_without_a_whole_gate_is_the_run_it_was \
                   qasm::whole_tests::a_lowering_that_needs_standard_gates_writes_them \
                   qasm::whole_tests::the_bit_exact_report_states_what_the_lowering_did \
                   qasm::whole_tests::a_loop_of_wide_whole_gates_is_held_to_what_a_program_may_hold; do
            grep -q "^test $t \.\.\. ok$" "$RUNNER_TEMP/qasm.log" || { echo "::error::$t did not run and pass"; exit 1; }
          done
      - name: The conformance corpus
        shell: bash
        working-directory: wai/wai-quantum
        run: |
          set -euo pipefail
          cargo test --locked --release --features full --test qasm3_conformance 2>&1 | tee "$RUNNER_TEMP/corpus.log"
          grep -q 'test result: ok. 2 passed; 0 failed' "$RUNNER_TEMP/corpus.log" || { echo "::error::the corpus did not pass"; exit 1; }
      - name: The reader without the lowerings
        shell: bash
        working-directory: wai/wai-quantum
        run: |
          set -euo pipefail
          cargo check --locked --no-default-features --features quantum_lang --lib
          cargo check --locked --no-default-features --features quantum_toolchain --lib

  wasip2:
    name: corpus under wasm32-wasip2 (wasmtime)
    needs: relevant
    if: needs.relevant.outputs.run == 'true'
    runs-on: linux
    timeout-minutes: 60
    steps:
      - uses: actions/checkout@v5
      - name: Install Rust 1.99.1 with the wasm32-wasip2 target
        shell: bash
        run: |
          export PATH="$HOME/.cargo/bin:$PATH"
          command -v rustup >/dev/null 2>&1 || \
            curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y --profile minimal --default-toolchain 1.99.1
          rustup toolchain install 1.99.1 --profile minimal
          rustup default 1.99.1
          rustup target add --toolchain 1.99.1 wasm32-wasip2
          echo "$HOME/.cargo/bin" >> "$GITHUB_PATH"
      # The release binary, pinned by version and SHA-256, rather than a build from source.
      # Every WAI workflow that runs wasmtime pins this one version, and every run passes
      # -W nan-canonicalization=y -W relaxed-simd-deterministic=y: every NaN a float
      # instruction makes is the canonical one, and each relaxed SIMD instruction has one
      # behaviour on every host. A stock wasmtime leaves both off. The fixed relaxed
      # behaviour is the engine's own: on 50.0.1 relaxed_madd is fused (measured on arm64 and
      # x86_64), where WebAssembly's deterministic profile prescribes the unfused result.
      # The repository checks (scripts/check-wasmtime-pin.py) fail a workflow that pins another
      # release or runs wasmtime without both settings.
      - name: Install wasmtime 50.0.1
        shell: bash
        run: |
          set -euo pipefail
          [ "$(uname -m)" = x86_64 ] || { echo "::error::the pinned wasmtime archive is x86_64; this host is $(uname -m)"; exit 1; }
          if ! command -v xz >/dev/null 2>&1; then
            SUDO=""; [ "$(id -u)" -ne 0 ] && SUDO="sudo"
            $SUDO apt-get update -qq
            $SUDO apt-get install -y -qq xz-utils
          fi
          v=50.0.1
          f="wasmtime-v$v-x86_64-linux.tar.xz"
          curl --proto '=https' --tlsv1.2 -sSfL -o "$RUNNER_TEMP/$f" \
            "https://github.com/bytecodealliance/wasmtime/releases/download/v$v/$f"
          echo "685466455dd42a14774a86c36c8f2e45cbb9bd6d92a850139315df60a75498a5  $RUNNER_TEMP/$f" | sha256sum -c -
          tar -xJf "$RUNNER_TEMP/$f" -C "$RUNNER_TEMP"
          echo "$RUNNER_TEMP/wasmtime-v$v-x86_64-linux" >> "$GITHUB_PATH"
      # A debug build, so integer overflow panics instead of wrapping. The test
      # that reads the corpus's files has no wasip2 build; the one that runs the
      # cases from the compiled-in bundle does.
      - name: The conformance corpus under wasmtime
        shell: bash
        working-directory: wai/wai-quantum
        env:
          CARGO_TARGET_WASM32_WASIP2_RUNNER: wasmtime run -W nan-canonicalization=y -W relaxed-simd-deterministic=y
        run: |
          set -euo pipefail
          cargo test --locked --target wasm32-wasip2 --features full --test qasm3_conformance 2>&1 | tee "$RUNNER_TEMP/wasip2.log"
          grep -q 'test result: ok. 1 passed; 0 failed' "$RUNNER_TEMP/wasip2.log" || { echo "::error::the corpus did not pass under wasip2"; exit 1; }