Skip to content
CAI
Software that uses CAICheck a score

sbt/zinc

57.2

Adequate · 6 November 2026

30.3k

lines of production code

Scala

with Java

4

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add CI and bridge validation scripts

The repository now includes new shell scripts in the bin directory to support development workflows. run-ci.sh executes the full CI suite, including formatting checks, compilation, documentation generation, bridge cross-tests, and scripted tests. bridge213.sh provides a standalone method to validate the compilation of the Scala 2.13 compiler bridge without relying on sbt, useful for bootstrapping or source-compatibility checks. deltag.sh is a utility script containing commands to delete a large number of historical git tags.

bin · high confidence

Add Java 25 support for main class detection

The compiler bridge now detects main classes in Java 25+ projects by checking for the \main\ method in the \module-info.class\ file, in addition to the traditional \public static void main(String\[\])\ method. This ensures that applications using the new Java 25 main class feature are correctly identified and executed.

internal/compiler-bridge · high confidence

Added InternalApiProxy for efficient deserialization of analysis files

A new proxy object, InternalApiProxy, has been added to the binary converters package to facilitate the efficient deserialization of incremental compilation analysis files. This component uses reflection to access private constructors of the xsbti.api.Modifiers class, enabling the creation of utility objects required for internal processing. As this is an internal API with no binary compatibility guarantee, it is not intended for public consumption and may change in minor releases.

internal/zinc-persist/src/main/scala/sbt/internal/inc/binary · high confidence

Added generated ReporterConfig class for compile reporting settings

A new \ReporterConfig\ class has been added to the \xsbti\ package. This generated artifact defines the configuration structure for the compiler's reporting mechanism, including fields for logger name, maximum error count, color usage, message and file filters, log level, and position mapping. It provides immutable builder-style methods (\with\*\) and standard \equals\, \hashCode\, and \toString\ implementations, enabling consistent configuration of how compilation output is reported to users.

internal/zinc-compile-core/src/main/contraband-java · high confidence

Added test utilities for source information analysis

The zinc-testing module now includes TestSourceInfo and TestSourceInfos classes to support incremental compilation testing. TestSourceInfo provides empty arrays for reported problems, unreported problems, and main classes, while TestSourceInfos implements ReadSourceInfos to return these test source info instances for any virtual file reference.

internal/zinc-testing/src/main/scala/xsbti · high confidence

Expose default FileAnalysisStore in Java API

A new Java interface, FileAnalysisStore, has been added to the xsbti.compile package to provide users with a direct way to access the default binary file-based analysis store. This interface exposes static getDefault methods that allow Java consumers to instantiate the underlying sbt internal FileAnalysisStore implementation for reading and writing incremental compilation analysis data to the file system.

internal/zinc-persist/src/main/java/xsbti/compile · high confidence

Introduce ZincCompilerUtil interface for Scala compiler access

A new \ZincCompilerUtil\ interface has been added to the \xsbti.compile\ package, providing static methods to retrieve the default incremental compiler, create Scala compilers from a \ScalaInstance\ and bridge JAR, and obtain a constant \CompilerBridgeProvider\. This interface delegates to \ZincUtil\ and serves as a unified utility for external build tools to control compiler retrieval and configuration.

zinc/src/main/java · high confidence

Introduce internal ZIP file manipulation utilities

Added new internal classes (ZipCentralDir, ZipConstants, ZipUtils) to handle ZIP central directory parsing, modification, and writing at specific offsets, supporting ZIP64 formats and replacing deprecated date handling with java.time APIs for more efficient in-place ZIP updates.

internal/zinc-classfile/src/main/java · high confidence

New Java class file discovery and analysis infrastructure

Added new \ClassFinder\ and \AnalyzingJavaCompiler\ components in the \zinc/src/main/scala/sbt/internal/inc/javac\ package to improve how Java compilation outputs are processed. The \ClassFinder\ trait introduces \DirectoryClassFinder\ and \JarClassFinder\ implementations that efficiently locate \.class\ files in output directories and JAR archives respectively, handling resource cleanup for JAR file systems. The \AnalyzingJavaCompiler\ integrates these finders to support 'straight to jar' compilation and tracks dependencies on inlined \static final\ constants via a local compiler interface, ensuring that incremental build analysis correctly captures Java-to-Java dependencies that would otherwise be lost during bytecode erasure.

zinc/src/main/scala/sbt/internal/inc/javac · high confidence

New ReporterUtil API for creating reporters

A new \ReporterUtil\ interface has been added to the public API, providing static methods to create \Reporter\ instances. Users can now obtain reporters using a \ReporterConfig\, a \PrintWriter\, a \PrintStream\, or an \xsbti.Logger\, with the implementation delegating to \ReporterManager\.

internal/zinc-compile-core/src/main/java/xsbti · high confidence

New cache-aware analysis store for incremental compilation

Added CacheAwareStore and CacheProvider in the zinc-persist module to enable checking for previously compiled analysis before falling back to local storage. This allows the incremental compiler to retrieve cached compilation results, improving build performance by avoiding redundant work when cached data is available.

internal/zinc-persist/src/main/scala/sbt/internal/inc/cached · high confidence

New generic read/write mappers for machine-independent analysis files

Zinc now includes new \GenericMapper\, \ReadMapper\, and \WriteMapper\ interfaces in the \xsbti.compile.analysis\ package, along with \RootPaths\ and \ReadWriteMappers\ helpers. These components allow the incremental compiler to transform file paths and compiler options when serializing and deserializing analysis files, enabling the creation of machine-independent analysis data that can be distributed across different environments. The \ReadMapper\ and \WriteMapper\ interfaces provide static factory methods for machine-independent mappers (using relative paths) and no-op mappers, giving build tools the ability to customize how analysis data is stored and retrieved.

internal/zinc-persist/src/main/java/xsbti/compile/analysis · high confidence

New read-only analysis API for inspecting compilation history and file stamps

The Zinc compiler interface now exposes a set of new read-only interfaces—ReadCompilations, ReadSourceInfos, ReadStamps, Compilation, SourceInfo, and Stamp—allowing users to inspect detailed information about past incremental compilations. This includes retrieving compilation timestamps and output directories, mapping source files to their compiler problems (both reported and unreported) and detected main classes, and accessing stamps (hashes and last-modified times) for sources, products, and library dependencies. This enables better debugging, regression testing, and analysis of Zinc's incremental behavior.

internal/compiler-interface/src/main/java/xsbti/compile/analysis · high confidence

New text-based serialization format for incremental analysis

Zinc now supports a human-readable, text-based format for persisting incremental compilation analysis data. This new format, implemented in the \sbt.internal.inc.text\ package, serializes compilation setup, dependency relations, stamps, APIs, and source information into plain text files (currently version 8). It includes dedicated formatters for \AnalyzedClass\, \Compilation\, \Relations\, and \Companions\, allowing external tools to inspect or manipulate analysis data more easily than with the previous binary format, while maintaining performance through optimized reading and writing logic.

internal/zinc-persist/src/main/scala/sbt/internal/inc/text · high confidence

New utility classes and auxiliary file extensions for incremental compilation

This change introduces several new Java classes in the \xsbti.compile\ package to support incremental compilation features. \ClassFileManagerUtil\ provides static methods to retrieve the default classfile manager implementation based on \ClassFileManagerType\ or \IncOptions\. \IncOptionsUtil\ offers a helper to instantiate \IncOptions\ from a string map, supporting configuration keys for pipelining, ignored scalac options, and various manager types. Additionally, new singleton classes \TastyFiles\, \ScalaJSFiles\, and \ScalaNativeFiles\ are added as \AuxiliaryClassFileExtension\ instances, enabling the ClassFileManager to manage TASTy, Scala.js (.sjsir), and Scala Native (.nir) files respectively when added to \IncOptions.auxiliaryClassFiles\.

internal/zinc-core/src/main/java · high confidence

Public API additions for classpath options and compiler caching

The \xsbti.compile\ package now exposes two new public interfaces: \ClasspathOptionsUtil\ and \CompilerCache\. \ClasspathOptionsUtil\ provides factory methods (such as \manual\, \boot\, \auto\, and \noboot\) to simplify the creation of \ClasspathOptions\ for various compilation scenarios, including specific handling for Scala 2.13 and later versions. \CompilerCache\ offers helpers to manage \GlobalsCache\ instances, including a \fresh()\ method for creating new caches and a deprecated \createCacheFor\ method for legacy usage.

internal/zinc-compile-core/src/main/java/xsbti/compile · high confidence

Support for incremental compilation directly to JAR files

Users can now compile Scala code directly into a JAR file, with incremental updates handled by merging new classes into the existing JAR rather than replacing it entirely. This change introduces \JarUtils\ and \IndexBasedZipFsOps\ to manage JAR central directory operations efficiently, allowing for the addition, removal, and merging of entries without rewriting the entire archive. It also includes specific compiler options (\-YdisableFlatCpCaching\ for scalac and \-XDuseOptimizedZip=false\ for javac) to ensure correct behavior during this process.

internal/zinc-classfile/src/main/scala/sbt/internal/inc · high confidence

Zinc incremental compiler core implementation

The internal zinc-compile-core module now contains the full implementation of the incremental compiler, including the AnalyzingCompiler for dependency-aware compilation, CompilerArguments for constructing Scala compiler flags, and a new logging/reporting system (LoggedReporter, ManagedLoggedReporter, FilteredReporter) that integrates with sbt's ManagedLogger for structured event logging. Output handling is standardized via CompileOutput helpers for single and multiple output directories, while file identity and hashing are managed through PlainVirtualFile and HashUtil (using FarmHash and SHA-256). A ReporterManager centralizes reporter creation based on configuration, and a RawCompiler provides a non-incremental interface for compiling compiler-bridge code.

internal/zinc-compile-core/src/main/scala/sbt/internal/inc · high confidence

Architecture

Zinc incremental compiler restructured into new subprojects

The Zinc codebase has been reorganized into distinct subprojects (compiler-bridge, compiler-interface, zinc-apiinfo, zinc-classfile, zinc-compile-core, and zinc-core), introducing new core abstractions such as VirtualFileRef and HashedVirtualFileRef for file identification, a dedicated ClassFile parser for bytecode analysis, and a new Analysis model that explicitly tracks SourceInfos and Compilations alongside stamps and APIs. This restructuring supports improved incremental compilation performance and more granular dependency tracking, including the ability to detect API changes via name hashing and handle auxiliary class files.

repository · high confidence

Behavioural changes

10 commits (0 fixes) modifying internal/zinc-testing/src/main/scala/sbt

A change to existing behaviour in internal/zinc-testing/src/main/scala/sbt — 10 commits, 3 files: “Migrate UnitSpec / AnyFlatSpec suites to Hedgehog”; “Break the dependency on LM, and thus Ivy”; “Apply header”; and 7 more (refs \#1659, \#1862).

internal/zinc-testing/src/main/scala/sbt · medium confidence · unverified

2 commits (0 fixes) modifying zinc/src/sbt-test/reporter

A change to existing behaviour in zinc/src/sbt-test/reporter — 2 commits, 7 files: “Let scripted check commands see the errors of a failed compile (\#1776)”; “Helper to check reported messages in Zinc scripted tests” (refs \#1776).

zinc/src/sbt-test/reporter · medium confidence · unverified

36 commits (4 fixes) modifying internal/zinc-classpath/src/main/scala/sbt/internal/inc

A change to existing behaviour in internal/zinc-classpath/src/main/scala/sbt/internal/inc — 36 commits (4 fixs), 3 files: “Clean up Scaladoc errors”; “\[2.x\] Replace Manifest with ClassTag”; “Apply header”; and 32 more (refs \#1630).

internal/zinc-classpath/src/main/scala/sbt/internal/inc · medium confidence · unverified

49 commits (4 fixes) modifying internal/zinc-classpath/src/main/scala/sbt/internal/inc/classpath

A change to existing behaviour in internal/zinc-classpath/src/main/scala/sbt/internal/inc/classpath — 49 commits (4 fixs), 5 files: “support detect dotty plugins”; “Apply header”; “Convert lastModified() to sbt.io.Milli.getModifiedTime(), more precise”; and 46 more (refs \#1641, \#1706).

internal/zinc-classpath/src/main/scala/sbt/internal/inc/classpath · medium confidence · unverified

Binary compatibility filters added for Zinc 1.0.0

A new backwards-compatibility exclusion file has been created for version 1.0.0, explicitly ignoring DirectMissingMethodProblem errors for specific methods within the \sbt.internal.inc.binary.BinaryAnalysisFormat\ and \ProtobufWriters\/\ProtobufReaders\ converters. This ensures that internal binary format changes in these components do not trigger false-positive binary incompatibility warnings during migration checks.

internal/zinc-persist/src/main/mima-filters · high confidence

Compiler interface API data model regenerated with content hashing and provenance

The \xsbti.api\ data model classes (such as \AnalyzedClass\, \ClassLike\, and \DependencyContext\) have been regenerated using Contraband 0.9.0. This update introduces new fields to \AnalyzedClass\ for \provenance\, \bytecodeHash\, and \transitiveBytecodeHash\ to support content-based change detection, and adds \DependencyByMacroExpansion\ to the \DependencyContext\ enumeration to track dependencies discovered during macro expansion. These changes enhance the compiler interface's ability to accurately detect API changes and optimize incremental compilation.

internal/compiler-interface/src/main/contraband-java/xsbti/api · high confidence

Compiler interface refactored to use VirtualFile and support Scala 3 compatibility

The Zinc compiler interface has been updated to replace concrete file references with a new VirtualFile abstraction, allowing analysis metadata to be portable across different machines and build environments. This change introduces a new AnalysisCallback interface hierarchy (AnalysisCallback through AnalysisCallback4) to support incremental compilation features, including better dependency tracking for Scala 3 (distinguishing between classes and companion objects via ClassRef and NameKind), enhanced error reporting with source information, and support for interactive console operations. The interface also adds support for capturing used names with specific scopes and qualifiers, enabling more precise incremental compilation invalidation.

internal/compiler-interface/src/main/java/xsbti · high confidence

Compiler interface schema expanded with pipelining, provenance, and bytecode hashing

The internal compiler interface schema has been updated to support new incremental compilation capabilities. The \IncOptions\ type now includes a \pipelining\ flag (defaulting to false) to enable build pipelining, an \auxiliaryClassFiles\ field to track additional class files, and an \allowMachinePath\ option. The \AnalyzedClass\ record has been extended with \provenance\ (to identify the source JAR) and \bytecodeHash\/\transitiveBytecodeHash\ fields (added in version 2.0.0) to support content-based invalidation. Additionally, the \ClassLike\ definition now exposes \childrenOfSealedClass\ and \topLevel\ fields, and the \NameHash\ record now includes a \scope\ field to distinguish between different usage contexts.

internal/compiler-interface/src/main/contraband · high confidence

Improved Java classfile analysis with annotation support and robust error handling

The Java incremental analysis engine now parses annotations from classfiles to detect usage dependencies, ensuring that changes to annotated types trigger correct recompilations. To improve stability, the classfile parser no longer fails the build if annotation parsing encounters malformed data; instead, it logs a warning and continues, preventing crashes from non-critical bytecode issues. Additionally, the analysis now correctly tracks transitive supertypes for referenced Java types and handles inner classes more accurately, reducing false negatives in dependency tracking.

internal/zinc-classfile/src/main/scala/sbt/internal/inc/classfile · high confidence

Introduce configurable temporary directory for text-based analysis store

The text-based file analysis store now accepts an explicit \tmpDir\ parameter, allowing users to specify where temporary files are created during the serialization of compilation analysis data. Previously, the store relied on the system's default temporary directory; the new API exposes this configuration point to ensure predictable file placement or to use specific storage locations.

internal/zinc-persist/src/main/scala/sbt/internal/inc · high confidence

Major refactor of the Zinc compiler interface API

The \xsbti.compile\ package has been completely rewritten to modernize the incremental compiler's public API. This change introduces new core interfaces such as \IncrementalCompiler\, \CompilerInterface2\, and \AnalysisStore\ to replace older patterns, and migrates null-safety from \xsbti.Maybe\ to Java's \java.util.Optional\. The API now supports advanced incremental compilation features including early output, early analysis, and external hooks for custom class file management and provenance tracking. Additionally, it standardizes file handling via \VirtualFile\ and \VirtualFileRef\, adds support for mixed Java/Scala compilation ordering, and provides a cleaner \ClassFileManager\ interface for managing generated class files.

internal/compiler-interface/src/main/java/xsbti/compile · high confidence

New Java-based lazy evaluation and modifier models in the compiler interface

The \xsbti.api\ package now includes new Java classes to support the incremental compiler's API contract without depending on Scala runtime libraries. \SafeLazy\ provides a thread-safe, memory-efficient lazy evaluation mechanism using Java \Supplier\ thunks, ensuring references are cleared after evaluation to prevent leaks. \AbstractLazy\ and \Lazy\ define the core serialization-safe lazy interface, while \Modifiers\ introduces a compact, serializable model for representing Scala modifiers (such as abstract, final, sealed, and macro) via bit flags. These changes replace previous Scala-dependent implementations, improving stability and reducing memory overhead in the compiler interface layer.

internal/compiler-interface/src/main/java/xsbti/api · high confidence

New consistent incremental analysis format with parallel compression

Zinc introduces a new serialization format for incremental compilation state (ConsistentAnalysisFormat) that replaces the previous Java serialization and Protocol Buffer approaches. This new format ensures reproducible output files—identical internal states always produce identical byte-for-byte files—and offers smaller file sizes and faster serialization/deserialization performance. The implementation includes a parallel gzip compression layer (ParallelGzipOutputStream) to speed up I/O, a NodeCache for efficient API node interning to prevent quadratic behavior during deserialization, and support for both binary (production) and text (debugging) output modes.

internal/zinc-persist/src/main/scala/sbt/internal/inc/consistent · high confidence

Optimized classpath hashing with metadata caching

The incremental compiler now caches JAR file hashes alongside their modification time and size in ClasspathCache. This allows the compiler to skip re-hashing unchanged JARs across different projects, significantly reducing I/O and improving build performance for large classpaths.

zinc/src/main/scala/sbt/internal/inc/caching · high confidence

Project configuration and documentation overhaul

This change introduces a comprehensive set of new configuration files and documentation to standardize the development environment and contributor experience. A new \.scalafmt.conf\ enforces Scala 3 formatting rules and specific style guidelines, while \.gitignore\ and \.gitattributes\ are added to manage build artifacts and ensure consistent line endings for test data. Developer workflows are supported by \.jvmopts\ for JVM settings, \.scala-steward.conf\ for dependency updates, and new \CONTRIBUTING.md\, \AGENTS.md\, \LLM\_POLICY.md\, and \MIGRATION.md\ files that outline coding standards, testing procedures, and AI usage policies. Additionally, the \LICENSE\ and \NOTICE\ files are updated to reflect the Apache 2.0 license and current copyright holders.

(repo-wide) · high confidence

Record API for un-loadable Java classes via classfile parsing

Zinc now generates API information for Java classes that cannot be loaded via reflection by parsing their classfiles directly. This fallback ensures that name-hashing remains accurate for these classes when their public shape changes, preventing missed dependencies in incremental builds.

internal/zinc-apiinfo/src/main/scala/sbt · high confidence

Refactor API info hashing and discovery into new Scala 3 implementation

The internal API info module has been refactored to use a new Scala 3 implementation, introducing dedicated classes for API utility functions, discovery of base classes and annotations, and pattern-matching target hashing. The \NameHashing\ class now supports an \optimizedSealed\ mode that generates specific hashes for sealed class children under a \PatMatTarget\ scope, improving incremental compilation accuracy for pattern matching. Additionally, the \HashAPI\ and \SameAPI\ logic has been restructured to handle definition grouping and equality checks with new parameters for including private definitions and sealed children, while \SafeLazyProxy\ bridges Java \SafeLazy\ functionality to Scala.

internal/zinc-apiinfo/src/main/scala/xsbt · high confidence

Refactored Java compilation infrastructure with new diagnostics and forking support

The Java compilation subsystem in \internal/zinc-compile-core\ has been restructured to improve reliability and compatibility. A new \DiagnosticsReporter\ now uses \java.util.Optional\ for position data and implements a thread-safe \PositionImpl\ to resolve race conditions that previously caused \NullPointerException\s during compilation. The \LocalJava\ implementation has been updated to use \scala.jdk.CollectionConverters\ instead of deprecated Java converters, and \ForkedJava\ introduces a forking strategy that utilizes argument files to bypass Windows command-line length limitations. Additionally, \JavacLogger\ and \ProcessLoggerWriter\ provide more robust handling of compiler output and error reporting.

internal/zinc-compile-core/src/main/scala/sbt/internal/inc/javac · high confidence

Reorganize internal compiler components under the 'zinc' name

The internal build structure has been reorganized to rename the incremental compiler subprojects with the 'zinc' prefix (e.g., zinc-core, zinc-compile-core, zinc-apiinfo). This change updates the internal module layout and adds corresponding NOTICE files to clarify licensing for these components, but does not alter the external build interface or user-facing behavior.

internal · high confidence

Support for relative path serialization in compilation analysis

The incremental compiler now supports storing file paths as relative to specific roots (sources, libraries, products) in the compilation analysis cache. New \RelativeReadMapper\ and \RelativeWriteMapper\ classes handle the conversion of absolute paths to and from a relative format, using a special marker to ensure robustness against empty paths and format mismatches. This change allows the build cache to be more portable and resilient to directory structure changes, as long as the relative roots remain consistent.

internal/zinc-persist/src/main/scala/sbt/internal/inc/mappers · high confidence

Updated compiler interface data structures and options

The compiler interface's generated Java classes have been updated to support new incremental compilation features. IncOptions now includes pipelining (disabled by default), strict mode, machine path allowance, and ignored scalac options. CompileOptions adds support for temporary classes directories, file conversion, and early output. New types include ClassFileManagerType (with DeleteImmediatelyManagerType), AuxiliaryClassFiles, and FileHash, while ClasspathOptions exposes autoBoot and filterLibrary settings.

internal/compiler-interface/src/main/contraband-java/xsbti/compile · high confidence

Zinc 2.x incremental compiler core rewritten in Scala 3

The Zinc incremental compiler core has been rewritten in Scala 3, introducing a new internal architecture for API analysis, class file management, and invalidation. This change replaces the previous implementation with Scala 3-specific components like \WrappedSet\ and \AnalysisInterner\, and introduces new data structures such as \APIs\ for managing internal and external class APIs, \Compilations\ for tracking compiler runs, and \ClassFileManager\ for handling class file generation and deletion. The invalidation logic is now driven by \IncrementalNameHashing\ and \IncrementalCommon\, which handle cycle-based compilation, package object invalidation, and member reference dependencies. Additionally, a new \InvalidationProfiler\ provides detailed profiling of the invalidation process, and \FileValueCache\ offers a path-based caching mechanism. These changes represent a significant architectural shift in how Zinc manages incremental compilation state and dependencies.

internal/zinc-core/src/main/scala · high confidence

Zinc incremental compiler refactored to Scala 3

The Zinc incremental compiler implementation in \sbt/internal/inc\ has been rewritten in Scala 3. This migration updates the codebase to use Scala 3 syntax and libraries (such as \scala.jdk.OptionConverters\), introduces new internal configuration and utility classes (like \CompileConfiguration\ and \ZincUtil\), and enforces stricter compilation rules, such as rejecting the \JavaThenScala\ compile order when build pipelining is enabled.

zinc/src/main/scala/sbt/internal/inc · high confidence

Test coverage

17 commits adding/updating tests in internal/zinc-core/src/test; 3 commits adding/updating tests in internal/zinc-classpath/src/test; Added JMH benchmarks for Zinc analysis format and file conversion; Added Java test resources for incremental compiler validation; Added benchmark for NodeCache intern performance; Added compiler bridge test suite; Added comprehensive test suite for Zinc incremental compiler; Added golden tests to pin the analysis serialization format; Added performance test resource for compiler bridge; Added sbt integration tests for Zinc API info; Added scripted test runner entry point; Added scripted tests for bridge selection and classpath filtering; Added scripted tests for incremental compilation edge cases; Added test cases for cycle detection with pipelining disabled; Added test coverage for InternalApiProxy.Modifiers; Added test coverage for class file management, compiler arguments, and virtual directories; Added test fixtures for Zinc resource generation; Added test resource files for incremental compilation scenarios; Added test resource for NoopMacro; Added test resource sources for incremental compilation tests; Added test resources for implicit member usage scenarios; Added test resources for incremental compilation scenarios; Added test suite for Java compiler integration and error handling; Added tests for API hashing stability and name hashing behavior; Added tests for Java classfile analysis and ZIP operations; Added tests for binary analysis format and mappers; Added tests for inner-class canonical naming and un-loadable class API extraction; Added tests for text analysis format and deserialization safety; Added tests for the consistent analysis format and parallel gzip compression; Expanded scripted tests for macro invalidation and type changes; New Zinc incremental-compiler scripted test infrastructure; Scripted tests for pipelining edge cases; Updated test data for the new analysis format.

Dependencies

Build infrastructure upgraded to sbt 2.x with centralized dependency management

The build system has been upgraded to sbt 2.0.9, introducing a centralized \project/Dependencies.scala\ file that manages all library versions, including Scala 3.9.0, Scala 2.13.16, and various sbt utility modules. This change consolidates dependency definitions, updates core plugins like sbt-contraband and sbt-scalafmt, and introduces new build plugins such as \HouseRulesPlugin\ for compiler options and \CustomHeaderPlugin\ for license headers, while also embedding a custom \Scripted\ runner to support the new sbt bridge architecture.

project · high confidence

Zinc 2.0.0-M9 build configuration and scripted test updates

The Zinc incremental compiler build is configured for version 2.0.0-M9-SNAPSHOT with early-semver versioning. The root project aggregates all subprojects (zinc, zincCore, zincCompileCore, etc.) and configures publishing to Maven Central Snapshots. The build enables Scala 3 compilation with -Werror, sets JVM 8 release targets for Scala 2.12+, and configures the semanticdb-scalac compiler plugin. Scripted tests are configured to watch source changes in the zinc/src/sbt-test directory and use the zinc3 project's sbt-test directory as the test source. Multiple scripted test cases are added or updated to configure specific compilation behaviors including mixed compile order, name hashing, class file name limits, and recompile fraction settings for precise dependency tracking testing.

(dependencies) · high confidence

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

How this codebase got here

Score

  • CAI 59 → 57 (-1.7)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.

Lenses

  • Code Health 60 → 60 (+0.1)
  • Architecture 90 → 90 (-0.1)
  • Maturity 50 → 52 (+2.5)
  • Readiness 68 → 67 (-1.2)
  • Security 73 → 55 (-18.0)
  • Performance 79 → 79 (+0.6)

Resolved (5)

  • Documentation: no architecture or design documentation (README.md)
  • MappedFileConverter.toVirtualFile (cognitive 17) (internal/zinc-core/src/main/scala/sbt/internal/inc/MappedVirtualFile.scala)
  • Off-boarding risk: anonymized user #1
  • Outdated: org.scala-lang:scala3-sbt-bridge
  • TodoComment (internal/zinc-core/src/main/scala/sbt/internal/inc/Incremental.scala)

New (23)

  • Dependency hygiene PARTLY measured — sbt declarations read, dependency currency not (Maven Central unreachable)
  • Low cohesion: JavaErrorParser (LCOM4 4) (internal/zinc-compile-core/src/main/scala/sbt/internal/inc/javac/JavaErrorParser.scala)
  • Off-boarding risk: anonymized user #1
  • Orphaned file (internal/compiler-bridge/src/main/scala-2.12/xsbt/Compat.scala)
  • Orphaned file (internal/compiler-bridge/src/main/scala/xsbt/Analyzer.scala)
  • Orphaned file (internal/compiler-bridge/src/main/scala/xsbt/CallbackGlobal.scala)
  • Orphaned file (internal/compiler-bridge/src/main/scala/xsbt/GlobalHelpers.scala)
  • Orphaned file (internal/compiler-bridge/src/main/scala_2.10/xsbt/Compat.scala)
  • Orphaned file (internal/compiler-bridge/src/main/scala_2.11-12/xsbt/ConsoleBridge.scala)
  • Orphaned file (internal/compiler-interface/src/main/java/xsbti/api/Modifiers.java)
  • Orphaned file (internal/compiler-interface/src/main/java/xsbti/compile/ClassFileManager.java)
  • Orphaned file (internal/compiler-interface/src/main/java/xsbti/compile/CompileOrder.java)
  • Orphaned file (internal/compiler-interface/src/main/java/xsbti/compile/ExternalHooks.java)
  • Orphaned file (internal/compiler-interface/src/main/java/xsbti/compile/RunProfiler.java)
  • Orphaned file (internal/zinc-apiinfo/src/main/scala/xsbt/api/ShowAPI.scala)
  • Orphaned file (internal/zinc-classfile/src/main/scala/sbt/internal/inc/IndexBasedZipOps.scala)
  • Orphaned file (internal/zinc-core/src/main/java/xsbti/compile/IncOptionsUtil.java)
  • Orphaned file (internal/zinc-persist/src/main/java/xsbti/compile/analysis/GenericMapper.java)
  • Orphaned file (internal/zinc-persist/src/main/java/xsbti/compile/analysis/ReadMapper.java)
  • Orphaned file (internal/zinc-persist/src/main/java/xsbti/compile/analysis/WriteMapper.java)
  • …and 3 more

Changes since last survey

  • 27 commits — 16 feature/other, 11 fixes

By area

  • zinc/src — 7 commits
  • (repo) — 4 commits
  • internal/zinc-core — 4 commits
  • internal/zinc-compile-core — 2 commits
  • internal/zinc-persist — 2 commits
  • project/Dependencies.scala — 2 commits
  • project/build.properties — 2 commits
  • (root) — 1 commit
  • contributing-docs/01_coding_style.md — 1 commit
  • internal/compiler-bridge-test — 1 commit
  • internal/compiler-interface — 1 commit

Notable commits

  • fix: Merge pull request #1846 from retronym/fix/implicit-scope-object-singleton
  • fix: Merge pull request #1855 from hoangmaihuy/fix/reproducible-early-jar
  • fix: [2.x] fix: Allow pickle path to be virutal
  • fix: [2.x] fix: Fixes under compilations via one-hop invalidation (#1780)
  • fix: [2.x] fix: Record classpath hash entries by virtual id (#1877)
  • fix: [2.x] fix: Resolve virtual paths in javacOptions (#1879)
  • fix: [2.x] fix: Store problem positions by virtual id (#1878)
  • fix: [2.x] test: Fixes pipelined scripted test hanging
  • fix: fix: Don't record JDK class files as library dependencies (#1866)
  • fix: fix: Escape a newline at the start of a used name (#1860)
  • fix: fix: Report the pointer of a javac caret in the first column (#1861)
  • change: Let scripted check commands see the errors of a failed compile (#1776)
  • change: Merge pull request #1858 from eed3si9n/wip/pickle-write-virtual
  • change: Merge pull request #1859 from eed3si9n/wip/hedgehog
  • change: Migrate UnitSpec / AnyFlatSpec suites to Hedgehog
  • change: Update launcher-interface to 1.7.1 (#1868)
  • change: Update scala-parallel-collections to 1.3.0 (#1867)
  • change: [2.x] IO 1.13.6 (#1870)
  • change: [2.x] Prepare Java products and analysis before deferred compilation (#1869)
  • change: [2.x] Rename the new retryOnInitialCompileError setting to oneHopInvalidation (#1883)
  • …and 7 more

Architecture

  • Unchanged — 0 containers · 1 contexts · 0 edges

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

Survey your own repository

sbt/zinc 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.

About this page

  • The score is its most recent published measurement, taken on 6 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 728b7fdc7076179d97f4299f4f0f2abffac7937e — the exact code this score is about.
  • Scored under rubric-2026.11.2 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.3+preprod-60d1b390edf0.