zio/zio-intellij

This system is a ZIO IntelliJ plugin that enhances the development experience for Scala projects using the ZIO functional programming library. It provides IDE support through code inspections for common mistakes and simplifications, refactoring capabilities, and synthetic macro injection for features like caching and mocking. Additionally, it integrates a dedicated test runner for executing ZIO specs and offers debugging utilities that filter out runtime internals.

11 changes.

This period established the foundational structure of the ZIO IntelliJ plugin, including the SBT build system, licensing, and comprehensive documentation. It introduced core functionality such as ZIO test runner integration, visual indicators for forked effects, and a suite of code simplification inspections to enhance developer productivity.

9 changes.

This period focused on enhancing the IntelliJ plugin with ZIO-specific code inspections, quick-fix intentions, and postfix completions to catch common errors and streamline development. It also introduced new code navigation features, such as a service accessor usage searcher, and added synthetic macro support for both ZIO 1 and ZIO 2.

9 changes.

This period focused on expanding the ZIO test runner capabilities, including BSP support, package-level execution, and improved handling of mixed ZIO versions. It also introduced new Scala macro annotations for function caching and refined the debugger to skip ZIO runtime internals. Underlying infrastructure was strengthened with comprehensive platform-specific tests and plugin compatibility checks.

A new quick-fix intention named 'Choose another type alias' is now available for ZIO types (including ZLayer). When invoked on a type element, it searches for matching type aliases defined in the same scope and presents them as a template choice, allowing users to replace the current type with a more specific or alternative alias.

src/main/scala/zio/intellij/intentions/suggestions · high confidence

The ZIO IntelliJ plugin now includes a new 'SortById' icon, loaded from the bundled /icons/sortById.svg resource file. This icon is exposed via the icons package object for use in the IDE's UI components.

src/main/scala/zio/intellij/icons · high confidence

A new \presentation.scala\ utility file has been added to the \zio.intellij.synthetic.macros.utils\ package to handle the string representation of Scala types and parameters within the IDE. This implementation provides logic for rendering parameter clauses, type parameters (including variance and bounds), and annotations, while also handling specific parameter decorations such as call-by-name arrows, repeated parameter asterisks, and default value truncation. The code includes compatibility notes for the Scala plugin version 2020.2, ensuring consistent type presentation in synthetic macro contexts.

src/main/scala/zio/intellij/synthetic/macros/utils · high confidence

Users can now run and debug ZIO tests via the Build Server Protocol (BSP) environment. A new extension, BspEnvironmentZioTestRunnerExtension, detects ZTestRunConfiguration instances and extracts the specific test classes (from either AllInPackageTestData or ClassTestData) to be executed, enabling BSP-compatible test execution within the IDE.

src/main/scala/zio/intellij/testsupport/bsp · high confidence

The Scala plugin now provides synthetic code injection for the @jsonDerive annotation, automatically generating placeholder JsonCodec implicits in companion objects for sealed traits and case classes. Additionally, support has been added for the accessibleM and accessibleMM macro annotations, enabling correct type inference and accessor generation for ZManaged and multi-parameter environment services.

src/main/scala/zio/intellij/synthetic/macros · high confidence

This change establishes the foundational structure for the ZIO IntelliJ plugin by adding the Apache 2.0 license, a Contributor License Agreement (CLA), and a comprehensive README. The README details installation via the JetBrains Plugin Marketplace, supported IntelliJ IDEA versions, and key features including test runner support, refactorings, and inspections. Additionally, configuration files for version control (.gitignore) and code formatting (.scalafmt.conf) are introduced to standardize the development environment.

(repo-wide) · high confidence

Adds a complete test integration layer for ZIO projects, enabling users to run ZIO tests directly from the IDE gutter icons, create new ZIO Spec files via the 'Create New Test' action, and view test results in the built-in test runner. The implementation distinguishes between ZIO 1.x and ZIO 2.x test frameworks, handling specific runner requirements and providing clickable 'Expected vs Actual' diffs for assertion failures by parsing console output.

src/main/scala/zio/intellij/testsupport · high confidence

The macros module now includes a suite of Scala compiler macros that allow developers to annotate functions with \@Cached\, \@CachedInUserData\, \@CachedWithRecursionGuard\, and \@CachedWithoutModificationCount\. These annotations automatically generate code to cache function return values, significantly improving performance for frequently accessed computations. The \@Cached\ annotation supports parameter-based caching and a \cacheMode\ option to control invalidation behavior, while \@CachedWithRecursionGuard\ adds protection against infinite recursion. Additionally, \@CachedWithoutModificationCount\ offers memory-efficient caching using weak or soft references, and \@CachedInUserData\ stores cached values in the PSI user data for better lifecycle management.

macros · high confidence

A new \ZioAccessorUsagesSearcher\ component has been added to the IntelliJ plugin to improve code navigation for ZIO services. This searcher identifies and locates usages of accessor methods and fields defined within ZIO \Service\ traits by analyzing their companion objects. It enables users to jump directly to where specific service accessors are used in their codebase, enhancing the development experience for ZIO-based Scala projects.

src/main/scala/zio/intellij/searchers · high confidence

The plugin now includes several new inspections in the 'mistakes' category to help catch common ZIO-specific errors. These include detecting the use of \=\ instead of \\<-\ in for-comprehensions, mistakenly using \if\ guards instead of \ZIO.when\, incorrect usage of \.type\ vs \.Type\ for ZIO Prelude newtypes, defining ZIO Specs as classes instead of objects, removing error recovery from infallible effects, using \Nothing\ in contravariant \R\ type parameters, providing environment for effects that don't need it, leaving ZIO expressions or assertions unused, wrapping values in \Future\, \Try\, \Option\, or \Either\ instead of lifting them, yielding ZIO effects in for-comprehensions, and throwing exceptions inside \ZIO.fail\.

src/main/scala/zio/intellij/inspections/mistakes · high confidence

The plugin now offers postfix completions for ZIO effects, allowing you to type an expression followed by \.succeed\, \.fail\, or \.traverse\ to quickly wrap it in \ZIO.succeed\, \ZIO.fail\, or \ZIO.foreach\. These completions are rendered with custom icons and hint text for better visibility. Additionally, the underlying type-checking logic has been refactored into a new \TypeCheckUtils\ module, which introduces pattern-matchers for ZIO types (such as \ZIO\, \ZManaged\, and \ZStream\) and their specific variants (like \URIO\ or \Stream\), improving how the plugin identifies and handles ZIO-related code.

src/main/scala/zio/intellij/utils · high confidence

The ZIO IntelliJ plugin now offers a comprehensive set of new code simplification inspections in the \simplifications\ package. These inspections automatically suggest replacing verbose or redundant ZIO expressions with more idiomatic equivalents, including converting \\\>\ chains to for-comprehensions (and vice versa), simplifying \layer.build.use\ to \.provideLayer\, replacing \ZIO.sleep(...) \\> io\ with \io.delay(...)\, and converting \ZIO.access(\.get)\ to \ZIO.service\. Additional simplifications cover replacing \.map(\ =\> ())\ or \.as(())\ with \.unit\, converting \.catchAll(\_ =\> ZIO.unit)\ to \.ignore\, simplifying \.map(...).flatten\ to \.flatMap\, and replacing \ZIO.succeed(Left(...))\ or \ZIO.succeed(Right(...))\ with \ZIO.left\ or \ZIO.right\. The plugin also suggests using \ZIO.foreach\ instead of \ZIO.collectAll\, \ZIO.serviceWith\ instead of \ZIO.accessM\ or \ZIO.service.flatMap\, and \ZIO.die\ instead of \.orDie(ZIO.fail(...))\. These changes help users write cleaner, more concise ZIO code directly from the IDE.

src/main/scala/zio/intellij/inspections/simplifications · high confidence

This update introduces several new code inspections and synthetic macro support for ZIO projects. The \ProvideMacroInspection\ now analyzes \.provide\, \.provideSome\, and related methods for both ZIO 1 (\inject\, \injectSome\) and ZIO 2, helping users fix layer provision issues. New simplifications allow replacing \foreach\ loops with \foreach\_\/\foreachDiscard\, converting \if/else\ blocks to \ZIO.when\/\ZIO.unless\, and simplifying \assertTrue\ chains. Additionally, a \DiscardingZIOValueInspection\ warns when \.map\ results are discarded or when \.runDrain\ is used unnecessarily. The \MockableInjector\ and \ModulePatternAccessibleBase\ now generate synthetic members for \@mockable\ and \@accessible\ macros, supporting both ZIO 1 and ZIO 2 type structures. Finally, the \TestRunnerDownloader\ and \TestRunnerResolveService\ handle downloading and caching the ZIO test runner for specified versions.

repository · high confidence

The ZIO 2 test runner now supports executing all tests within a package in a single run. A new Java-based runner loads specified ZIO spec singletons via reflection, combines them using the ZIO test framework's combination operator, and invokes their main method once. This approach avoids the issue where sequential test runs would terminate early due to System.exit calls, allowing users to run an entire package's tests together without manual orchestration.

zio2-test-runner · high confidence

The IDE now displays a gutter icon next to ZIO effect calls that are explicitly forked (such as \.fork\, \.forkDaemon\, \.forkManaged\, \.forkAs\, \.forkOn\, \.forkWithErrorHandler\, and \ZIO.forkAll\). This visual marker helps developers quickly identify concurrent execution points in their code, improving readability and aiding in the review of parallel effect handling.

src/main/scala/zio/intellij/inspections · high confidence

The debugger now includes a stepping filter that prevents the user from stepping into classes within the ZIO package (matching the pattern zio.\*). This keeps the debugging session focused on application code by automatically skipping over the ZIO runtime implementation.

src/main/scala/zio/intellij/debugger · high confidence

The ZIO 1 test runner now correctly prompts users to download the runner only when all modules in a project use ZIO 1.0, preventing unnecessary or confusing prompts in mixed-version setups. This change introduces a new notification system that tracks displayed messages to avoid duplicates and provides clear success or error feedback when downloading the test runner components.

src/main/scala/zio/intellij/testsupport/zio1 · high confidence

The IDE plugin now offers intentions to suggest more specific type aliases for ZIO types. This change adds the core \ZTypeAnnotationIntention\ class and supporting \ZStrategy\ logic, which detects when a declared type originates from ZIO (via \fromZioLike\ or \fromZioLayer\) and triggers suggestions. This provides the foundation for quick-fixes that help users migrate from deprecated patterns or choose more precise type annotations within ZIO code.

src/main/scala/zio/intellij/intentions · high confidence

The plugin now checks for compatibility between the ZIO for IntelliJ plugin and the Scala plugin at startup. If a stable version of ZIO for IntelliJ is detected alongside an EAP or Nightly version of the Scala plugin, a warning notification appears, alerting users that this combination may cause unexpected issues. The notification provides an option to switch the ZIO plugin to its EAP channel to match the Scala plugin's build status, or to dismiss the warning for the current version combination.

src/main/scala/zio/intellij/startup · high confidence

The plugin's compatibility range has been updated to support IntelliJ IDEA 2025.1 (build 262.7574). This change ensures the ZIO enhancements, including inspections, refactorings, and test runner support, function correctly in the latest IntelliJ releases.

src/main/resources · high confidence

Added Scala plugin testkit base classes and library loaders; Added platform-specific tests for ZIO test run configuration paths; Added smoke test to verify required plugins are loaded; Added tests for @accessible and @mockable macro code generation; Added tests for ZIO accessor usage search; Added tests for ZIO inspection simplifications and mistake detection; Added tests for ZIO version parsing and comparison logic.

The project has been configured with an SBT build system to manage the IntelliJ plugin. This includes setting up SBT version 1.12.13, defining dependencies for Scala 2.13.18 and IntelliJ Platform 2026.2 (build 262.8665.258), and integrating the sbt-idea-plugin and sbt-scalafmt plugins. The configuration also specifies required IntelliJ plugins such as Java, Test Runner, and the IntelliJ Scala plugin for development and testing.

project · high confidence

The project build system has been established using SBT (build.sbt), defining the core 'zio-intellij' plugin module along with supporting sub-projects for the 'zio2-test-runner', 'macros', and 'scala-plugin-testkit'. This configuration sets the Java release target to 25 for the main plugin while ensuring the test runner targets Java 8 for broader compatibility, and integrates the IntelliJ plugin SDK and JUnit for testing.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• First survey — no prior run to compare against. CAI 46.

• Code Health 93
• Architecture 99
• Maturity 40
• Readiness 38
• Security 57
• Accessibility 51

• 300 commits — 262 feature/other, 38 fixes

• src/main — 160 commits
• (root) — 86 commits
• src/test — 27 commits
• .github/workflows — 20 commits
• project/plugins.sbt — 5 commits
• macros/src — 1 commit
• project/dependencies.scala — 1 commit

• fix: 296 fix exception in LambdaUtils
• fix: A temporary hack to fix Suggest Type Alias removing the dot in zio. (#464)
• fix: Bugfix release
• fix: Disabling .serviceWith simplification until some bugs can be fixed
• fix: Fix #201: *> ZIO.succeed -> .as (#225)
• fix: Fix @accessible accessors for ZStream/ZSink (#160)
• fix: Fix Ambiguous Layers error for collision names from different directories
• fix: Fix NPE when accessing the containing class property. Might not be there for top-level functions (#286)
• fix: Fix ZIO version parsing (#239)
• fix: Fix NeedsEnv detection (#200)
• fix: Fix collectAll inspection on maps
• fix: Fix compilation, remove unnecessary nowarn
• fix: Fix detection of ZIO expressions (#186)
• fix: Fix inspections
• fix: Fix inspections
• fix: Fix integration tests by always taking the latest ZIO 1.x
• fix: Fix prompting for test runner download for mixed ZIO projects
• fix: Fix test runner issue, bump version
• fix: Fix version toString
• fix: Fixed Scala 3 version detection for RC versions post 3.0.0 release
• …and 280 more

• 0 containers · 1 bounded contexts · 0 dependency edges (baseline)

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

zio/zio-intellij was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.