Dialyxir

To optimize Dialyxir runs in GitHub Actions, use a caching strategy for Preloaded Type Lists (PLTs). This prevents re-creating PLTs on every run, which is a time-consuming process.

Key implementation details:

1. Cache Key: Use a key that incorporates the runner OS, Erlang/OTP version, Elixir version, and the hash of mix.lock. This ensures the cache is invalidated when dependencies or the runtime change.
2. Cache Path: Store PLTs in priv/plts.
3. Separate Save Step: Use actions/cache/save as a distinct step from actions/cache/restore. This ensures that if mix dialyzer fails (which is common when new warnings are introduced), the successfully created PLT cache is still saved for future runs.
4. Output Formats: When running mix dialyzer, use both --format github and --format dialyxir.
   • --format github: Enables GitHub to display warnings directly in the Pull Request /files annotation view.
   • --format dialyxir: Ensures the raw logs contain the full warning details for easier debugging.

steps:
  - name: Check out source
    uses: actions/checkout@v2

  - name: Set up Elixir
    id: beam
    uses: erlef/setup-beam@v1
    with:
      otp-version: "24.1"
      elixir-version: "1.12.3"

  - name: Restore PLT cache
    id: plt_cache
    uses: actions/cache/restore@v3
    with:
      key: |
        plt-${{ runner.os }}-${{ steps.beam.outputs.otp-version }}-${{ steps.beam.outputs.elixir-version }}-${{ hashFiles('**/mix.lock') }}
      restore-keys: |
        plt-${{ runner.os }}-${{ steps.beam.outputs.otp-version }}-${{ steps.beam.outputs.elixir-version }-}
      path: |
        priv/plts

  - name: Create PLTs
    if: steps.plt_cache.outputs.cache-hit != 'true'
    run: mix dialyzer --plt
     
  - name: Save PLT cache
    id: plt_cache_save
    uses: actions/cache/save@v3
    if: steps.plt_cache.outputs.cache-hit != 'true'
    with:
      key: |
        plt-${{ runner.os }}-${{ steps.beam.outputs.otp-version }}-${{ steps.beam.outputs.elixir-version }}-${{ hashFiles('**/mix.lock') }}
      path: |
        priv/plts

  - name: Run dialyzer
    run: mix dialyzer --format github --format dialyxir

There are three ways to ignore warnings in Dialyxir:

1. Module Attribute

Use the @dialyzer attribute directly in your Elixir module to suppress specific warnings.

@dialyzer {:nowarn_function, rollback: 1}

2. Simple String Matches (Legacy)

Specify a file path via :ignore_warnings in mix.exs. This file contains lines that partially match the output of mix dialyzer --format dialyzer.

dialyzer: [ignore_warnings: "dialyzer.ignore-warnings"]

3. Elixir Term Format (Recommended)

Use a .dialyzer_ignore.exs file (or a custom path via :ignore_warnings). This file is an Elixir list containing tuples or Regexes. These are matched against the short-description format (mix dialyzer --format short).

To generate entries for your ignore file, use:

• mix dialyzer --format ignore_file (groups by file/type)
• mix dialyzer --format ignore_file_strict (more granular, recommended)

Example .dialyzer_ignore.exs content:

[
  {file, warning_type},
  {file, warning_description},
  {file},
  ~r/regex_pattern/
]

To optimize Dialyxir execution in CircleCI, you can cache the Preloaded Terminology (PLT) files. This prevents the expensive --plt creation step from running on every build.

Follow these steps in your CircleCI configuration:

1. Version Tracking: Save the current Elixir and Erlang versions to a file (e.g., .elixir_otp_version) to use as part of your cache key. This ensures that if the runtime changes, the cache is invalidated.
2. Restore Cache: Use a cache key that combines the architecture, the checksum of your version file, and the checksum of mix.lock. This ensures the cache is specific to your dependencies and runtime.
3. Create PLTs: Run mix dialyzer --plt to generate the PLTs if they are not restored from the cache.
4. Save Cache: Save the priv/plts directory using the same cache key used for restoration.
5. Run Dialyzer: Execute mix dialyzer as usual.

---
version: 2

jobs:
  build:
    docker:
      - image: cimg/elixir:1.14

    steps:
      - checkout

      # Compile steps omitted for simplicity

      # Cache key based on Erlang/Elixir version and the mix.lock hash
      - run:
          name: "Save Elixir and Erlang version for PLT caching"
          command: echo "$ELIXIR_VERSION $ERLANG_VERSION" > .elixir_otp_version

      - restore_cache:
          name: "Restore PLT cache"
          keys:
            - plt-{{ arch }}-{{ checksum ".elixir_otp_version" }}-{{ checksum "mix.lock" }}

      - run:
          name: "Create PLTs"
          command: mix dialyzer --plt

      - save_cache:
          name: "Save PLT cache"
          key: plt-{{ arch }}-{{ checksum ".elixir_otp_version" }}-{{ checksum "mix.lock" }}
          paths: "priv/plts"

      - run:
          name: "Run dialyzer"
          command: mix dialyzer

To optimize Dialyxir in GitLab CI, use a multi-stage pipeline that separates compilation from type checking. This allows you to cache dependencies and Precompiled Load Targets (PLTs) to prevent Dialyzer from needing to recompile the project in every job.

Key Strategies:

• Caching: Use .tool-versions and mix.lock as cache keys to ensure the cache is specific to your Erlang/Elixir versions and dependency tree.
• PLT Caching: Cache the priv/plts directory to share precompiled targets between jobs.
• Cache Policies:
  • Use pull-push for the job that generates the PLT (e.g., dialyzer-plt).
  • Use pull for jobs that only consume the PLT (e.g., dialyzer-check) to avoid unnecessary uploads.
• Job Dependencies: Use needs to ensure the type-checking stage only runs after the build and PLT generation stages are complete.

image: elixir:1.14

stages:
  - compile
  - check-elixir-types

build-dev:
  stage: compile
  cache:
    - key:
        files:
          - .tool-versions
          - mix.lock
      paths:
        - deps/
        - _build/dev
      policy: pull-push
  script:
    - mix do deps.get, compile

dialyzer-plt:
  stage: check-elixir-types
  needs:
    - build-dev
  cache:
    - key:
        files:
          - .tool-versions
          - mix.lock
      paths:
        - priv/plts
      policy: pull-push
  script:
    - mix dialyzer --plt

dialyzer-check:
  stage: check-elixir-types
  needs:
    - dialyzer-plt
  cache:
    - key:
        files:
          - .tool-versions
          - mix.lock
      paths:
        - priv/plts
      policy: pull
  script:
    - mix dialyzer --format short

The PLT is a cached output of the Dialyzer analysis used to avoid re-analyzing the standard library and OTP modules every time. By default, Dialyxir builds core Erlang/Elixir files in $MIX_HOME and a project-specific file in _build/$MIX_ENV/.

You can customize PLT behavior in your mix.exs using the following keys:

• :plt_core_path: Specify a custom path for the core Erlang/Elixir PLT files (instead of using $MIX_HOME).
• :plt_local_path: Specify a custom directory for the project-specific PLT file.
• :plt_file: Specify a custom filename for the project PLT. Note: This is deprecated for local use but useful in CI. To silence deprecation warnings in CI, use plt_file: {:no_warn, "/path/to/file"}.
• :plt_apps: Specify a list of applications to include in the PLT. Using this replaces the default apps ([:erts, :kernel, :stdlib, :crypto]) and prevents automatic dependency addition.
• :plt_add_apps: Add specific applications to the default list.
• :plt_ignore_apps: A list of applications to exclude from the PLT.