sbt/zinc

Zinc is an incremental compiler for Scala and Java that minimizes build times by tracking source dependencies and recompiling only affected code. It provides a robust API for build tools to manage compilation state, including content-based invalidation, pipelining, and portable analysis storage. The system supports mixed Java/Scala projects, macro expansion, and efficient JAR manipulation while ensuring binary compatibility across different environments.

30 changes.

This period focused on rewriting the Zinc incremental compiler core and its surrounding infrastructure to support Scala 3, including migrating the build system to sbt 1.x DSL and Scala 3. The work involved refactoring the compiler interface to use VirtualFile abstractions, implementing new API analysis and classfile parsing components, and establishing robust Java compilation support. Comprehensive test suites were added to validate incremental compilation behavior, pipelining, and dependency tracking across mixed Scala and Java projects.

29 changes.

This period focused on preparing the Zinc incremental compiler for a 1.0 release by introducing a new text-based serialization format and a comprehensive set of public APIs for caching, analysis, and configuration. The work involved refactoring internal persistence mechanisms to support portable, machine-independent file paths while expanding the public interface for build tool integration.

15 changes.

This period focused on replacing the legacy incremental analysis serialization with a new consistent, reproducible binary format featuring parallel compression and efficient node interning. Significant effort was also dedicated to expanding test coverage, including scripted tests for macro invalidation, unit tests for the compiler bridge, and JMH benchmarks to validate the performance of the new storage and file conversion mechanisms.

The bin directory now includes three new shell scripts: run-ci.sh, which executes the full continuous integration suite (including formatting checks, compilation, documentation, bridge tests, and scripted tests); bridge213.sh, a standalone validation script for compiling the Scala 2.13 compiler bridge without sbt; and deltag.sh, a utility for deleting a large list of historical git tags.

bin · high confidence

The compiler bridge now registers its core components via Java Service Provider interfaces, enabling automatic discovery by the build tool. New service files define the factory for the interactive console (\xsbt.InteractiveConsoleBridgeFactory\), the main compiler interface (\xsbt.CompilerBridge\), the console interface (\xsbt.ConsoleBridge\), and the Scaladoc interface (\xsbt.ScaladocBridge\).

internal/compiler-bridge · high confidence

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 within 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

A new Java class, xsbti.ReporterConfig, has been added to the zinc compile core. This generated artifact provides a structured configuration object for compile-time reporting, allowing users and internal components to define specific settings such as the logger name, maximum error count, color usage, message and file filters, log level, and position mapping. The class includes factory methods, immutable property accessors, and builder-style 'with' methods to facilitate the creation and modification of these reporting configurations.

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

The internal zinc classfile module now includes a new set of Java classes (ZipCentralDir, ZipConstants, ZipUtils) to handle ZIP file structures directly. This adds support for reading and writing ZIP central directories, including ZIP64 format handling, and provides utilities for converting between DOS, Windows, and Unix time formats used in ZIP entries. This enables more efficient in-place modification of ZIP archives without full recreation.

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

New \TestSourceInfo\ and \TestSourceInfos\ classes have been added to the \xsbti\ package within the zinc-testing module. These provide test implementations of the \SourceInfo\ and \ReadSourceInfos\ interfaces, returning empty arrays for problems and main classes, and an empty map for all source infos, facilitating testing scenarios where source metadata is not required.

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

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

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

Zinc now provides a new set of interfaces and utilities in the \xsbti.compile.analysis\ package to make compiled analysis files machine-independent. By introducing \GenericMapper\, \ReadMapper\, and \WriteMapper\, along with \RootPaths\ and \ReadWriteMappers\, the compiler can now transform file paths and compiler options during serialization and deserialization. This allows build tools to distribute analysis files across different machines or environments by mapping absolute paths to relative ones based on configurable root directories (sources, libraries, products), ensuring that incremental compilation state remains portable and consistent regardless of the local file system structure.

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

Adds new internal utilities (IndexBasedZipOps, IndexBasedZipFsOps, JarUtils) that enable efficient, index-based manipulation of JAR files. This allows the compiler to merge, update, and remove entries in output JARs by modifying only the central directory index rather than rewriting the entire archive, supporting the new 'straight to jar' compilation mode.

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

A new CacheProvider trait has been added to the internal zinc-persist module, defining the interface for locating compilation caches. This trait accepts previous compilation analysis and setup information to return an optional CompilationCache, establishing the foundational contract for how cached compilation data is retrieved during incremental builds.

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

Added new internal components for Java incremental compilation: \AnalyzingJavaCompiler\ handles Java source compilation with support for tracking dependencies on inlined \static final\ constants via \LocalJavaCompiler\, and \ClassFinder\ (including \DirectoryClassFinder\ and \JarClassFinder\) provides a unified way to discover \.class\ files from both directories and JAR archives for dependency analysis.

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

A new public interface, ReporterUtil, has been added to the xsbti package, providing static methods to create Reporter instances. This API allows users to obtain a default reporter or create one configured with specific settings, supporting output to standard streams (PrintStream, PrintWriter) or via an xsbti.Logger, thereby simplifying the integration of compilation reporting into build tools.

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

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 instances and bridge JARs, and obtain a constant compiler bridge provider. This interface delegates to \ZincUtil\ and serves as a unified utility for external build tools to control Scala compiler retrieval and configuration.

zinc/src/main/java · high confidence

This change introduces the core implementation files for the Zinc incremental compiler bridge and API analysis subsystem. It adds the \API\ and \Dependency\ phases to the compiler bridge (\internal/compiler-bridge\), which extract public APIs and track source-level dependencies during compilation. It also introduces the \ClassToAPI\ utility for analyzing Java class files into API representations, a \NameHashing\ class for computing stable hashes of definitions to detect changes, and a \JavaErrorParser\ for interpreting javac output. Additionally, it defines foundational interface classes like \BasicVirtualFileRef\ and \BasicHashedVirtualFileRef\ for file identification and hashing, and an \AuxiliaryClassFileExtension\ to support associated file tracking.

repository · high confidence

This change introduces a new \internal/zinc-classpath\ module containing core utilities for managing Scala classpaths and classloaders. It adds \ModuleUtilities\ and \ReflectUtilities\ for reflective object loading and \val\ inspection, and refactors \ScalaInstance\ to support multiple library jars and distinct classloaders for compiler vs. library code. The module also provides \ClassLoaderCache\ for caching classloaders based on file timestamps, \ClasspathFilter\ to restrict class loading to specific paths (including JDK platform modules), \DualLoader\ for merging two classloader hierarchies, and \RawURL\/\RawResources\ for in-memory resource injection. A test suite verifies the classpath filtering behavior.

internal/zinc-classpath · high confidence

Added \AbstractBridgeProviderTestkit\ and \UnitSpec\ to the \internal/zinc-testing\ module to standardize how internal tests interact with the compiler bridge. \AbstractBridgeProviderTestkit\ provides helper methods to fetch and cache compiler bridges and Scala instances, ensuring tests retrieve one bridge at a time via synchronization. \UnitSpec\ establishes a base class for test suites using ScalaTest, integrating a configurable \ManagedLogger\ with console output to handle test logging consistently.

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

The compiler interface now exposes a set of new read-only APIs in the \xsbti.compile.analysis\ package, allowing users to inspect incremental compilation history and file tracking data. \ReadCompilations\ provides access to past compilation runs (start time, output directories), while \ReadSourceInfos\ exposes per-source-file details such as reported/unreported compiler problems and detected main classes. \ReadStamps\ enables querying the tracked timestamps and hashes for source files, library dependencies, and compilation products, and \Stamp\ itself clarifies that empty values indicate untracked files. These interfaces are designed for diagnostics, regression testing, and tooling that needs to understand Zinc's incremental state.

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

The incremental compiler now includes a new \FileAnalysisStore\ implementation that persists compilation analysis data in a human-readable text format (zipped). This store allows users to configure the temporary directory used during the atomic write process and supports custom read/write mappers for path translation. It serves as the primary text-based storage backend, distinct from the binary format, enabling easier debugging and inspection of incremental compilation state.

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

This change introduces several new Java utility classes in the zinc-core module to improve configuration and support for auxiliary file types. IncOptionsUtil provides a helper to instantiate IncOptions from a string map, supporting various configuration keys like pipelining and classfile manager types. ClassFileManagerUtil offers static methods to retrieve default classfile manager implementations. Additionally, new singleton classes TastyFiles, ScalaJSFiles, and ScalaNativeFiles are added to manage TASTy, .sjsir, and .nir files respectively via the AuxiliaryClassFileExtension mechanism.

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

The repository has been initialized with essential configuration and documentation files. A new .scalafmt.conf enforces Scala 3 formatting rules (with specific overrides for the compiler bridge), and .gitignore excludes build artifacts and IDE files. Contributor guidance is provided via CONTRIBUTING.md, AGENTS.md, and LLM\_POLICY.md, while MIGRATION.md documents the removal of legacy Scala 2.7-2.9 support and the renaming of ClassfileManager to ClassFileManager.

(repo-wide) · high confidence

The internal zinc-compile-core module now contains the full implementation of the Zinc incremental compiler for Scala. This includes the core \AnalyzingCompiler\ for dependency-aware compilation, \CompilerArguments\ for constructing version-specific compiler flags, and a new event-logging reporter system (\LoggedReporter\, \ManagedLoggedReporter\, \FilteredReporter\) that integrates with sbt's logging infrastructure. The module also introduces \CompileOutput\ for managing single and multiple output directories, \HashUtil\ for file hashing, and \PlainVirtualFile\ for file abstraction, replacing previous external or fragmented implementations.

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

The \xsbti.compile\ package now exposes two new public interfaces: \ClasspathOptionsUtil\ and \CompilerCache\. \ClasspathOptionsUtil\ provides factory methods (such as \boot\, \auto\, \noboot\, and \javac\) to simplify the creation of \ClasspathOptions\, including logic that adjusts behavior based on the Scala version (e.g., handling 2.13+ differences). \CompilerCache\ offers helpers to obtain \GlobalsCache\ instances, notably a \fresh()\ method and a deprecated \createCacheFor\ method, allowing users to manage compiler instance caching more directly.

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

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

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

The Zinc compiler interface has been significantly updated to replace legacy java.io.File references with a new VirtualFile abstraction, enabling build metadata to be portable across different machines by storing relative path identities rather than absolute paths. This change introduces a new hierarchy of callback interfaces (AnalysisCallback through AnalysisCallback4) to support incremental compilation features, including the ability to distinguish between classes and companion objects via namespaces (ClassRef and NameKind) and to capture detailed source information and code actions for better error reporting and IDE integration.

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

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

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

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

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

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

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

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

The internal API analysis module has been refactored to improve performance and stability. Hashing of sealed class children is now stable, and the API comparison logic has been updated to correctly handle private trait definitions and avoid unnecessary allocations in hot code paths. Additionally, the system now properly handles annotations in the classfile parser and uses a more efficient lazy evaluation proxy.

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

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

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

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

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

The incremental compiler (Zinc) has replaced its previous Java serialization format with a new human-readable text-based format for storing analysis data. This change, implemented in the \internal/zinc-persist/src/main/scala/sbt/internal/inc/text\ package, introduces new serialization logic for compilation results, API information, and file stamps. Users should expect that existing cached analysis files will need to be regenerated, as the new format is not backward-compatible with the old binary format.

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

The Zinc incremental compiler implementation in \sbt/internal/inc\ has been rewritten in Scala 3. This change updates the internal compiler logic, configuration structures (such as \CompileConfiguration\), and utility classes to use Scala 3 syntax and libraries (e.g., \scala.jdk.OptionConverters\), ensuring compatibility with the Scala 3 compiler while maintaining the existing incremental compilation behavior for users.

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

The Zinc incremental compiler core has been rewritten to support Scala 3, introducing a new Scala 3-specific source directory (scala-3) and replacing the previous Scala 2 implementation. This update brings a redesigned API model via the new \APIs\ trait and \MAPIs\ implementation for managing internal and external class APIs, a new \AnalysisInterner\ for memory-efficient string and used-name canonicalization, and a refactored \ClassFileManager\ with updated factory methods and transactional support. Invalidation logic has been overhauled with new \IncrementalNameHashing\ heuristics, \CompanionsStore\, and detailed \InvalidationLog\ formatting, while \Lookup\ and \Locate\ components have been restructured to support faster classpath and analysis lookups. These changes fundamentally alter how Zinc tracks dependencies, manages class files, and determines recompilation needs for Scala 3 projects.

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

Add test fixtures for Zinc resource generation; 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 comprehensive test suite for Zinc incremental compiler; Added golden tests to pin the analysis serialization format; Added performance test resource for compiler bridge; Added scripted test runner entry point; Added scripted tests for error and warning reporting; Added test cases for cycle detection with pipelining disabled; Added test cases for main class discovery and incremental compilation edge cases; Added test coverage for InternalApiProxy.Modifiers; Added test coverage for Zinc core internals; Added test coverage for class file management, compiler arguments, and virtual directories; Added test for ClasspathFilter behavior; 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; Added unit tests for compiler bridge functionality; Expanded scripted tests for incremental compilation and pipelining; Expanded scripted tests for macro invalidation and type changes; New internal scripted test infrastructure for Zinc incremental compiler; Updated test data for the new analysis format version 1100029.

The build system has been upgraded to sbt 2.0.8, enabling support for Scala 3.9.0 alongside Scala 2.12.21 and 2.13.16. This change introduces a centralized dependency management file (Dependencies.scala) that defines versions for core modules like sbt/io (1.13.1) and sbt/util (2.0.8), and updates key plugins including sbt-contraband (0.9.0), sbt-header (5.11.0), and sbt-mima-plugin (1.1.6). The build now uses a custom scripted test runner and enforces stricter compiler warnings via HouseRulesPlugin, while also configuring sbt-buildinfo (0.13.2) and sbt-dynver (5.1.1) for versioning and build metadata.

project · high confidence

The Zinc build system has been upgraded from the legacy sbt 0.13 syntax to the modern sbt 1.x DSL, utilizing Scala 3 for the build definition itself. This migration introduces project matrix support for cross-compilation, updates the versioning scheme to early-semver, and configures publication to Maven Central Snapshots. Additionally, the build now enforces stricter compiler options, such as treating warnings as errors in Scala 3 and setting specific Java release targets, while removing legacy resolver configurations.

(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 61.

• Code Health 89
• Architecture 96
• Maturity 49
• Readiness 64
• Security 65

• 300 commits — 272 feature/other, 28 fixes

• (repo) — 79 commits
• project/Dependencies.scala — 45 commits
• (root) — 32 commits
• project/build.properties — 28 commits
• zinc/src — 21 commits
• project/plugins.sbt — 18 commits
• .github/workflows — 12 commits
• internal/zinc-core — 12 commits
• internal/zinc-compile-core — 9 commits
• internal/compiler-bridge-test — 6 commits
• internal/zinc-apiinfo — 6 commits
• internal/zinc-classfile — 6 commits
• internal/zinc-persist — 6 commits
• internal/zinc-classpath — 4 commits
• internal/zinc-scripted — 4 commits
• internal/compiler-interface — 3 commits
• .github/dependabot.yml — 2 commits
• internal/compiler-bridge — 2 commits
• internal/zinc-benchmarks — 2 commits
• project/Header.scala — 1 commit

• fix: Fix NoClassDefFoundError during post-compile analysis of inner classes
• fix: Fix hashes for directories in MappedVirtualFile
• fix: Fix old varargs splice syntax warnings (#1652)
• fix: Fix warnings in build.sbt
• fix: Fix windows CI
• fix: Merge pull request #1595 from xuwei-k/fix-warn
• fix: Merge pull request #1626 from MkDev11/fix/scala-library-substring-match
• fix: Merge pull request #1660 from BrianHotopp/fix/sbt-117-noclassdeffounderror-inner-classes
• fix: Merge pull request #1747 from raboof/fix-MappedVirtualFile-contentHashStr-for-directories
• fix: [2.x] Fix scaladoc (#1674)
• fix: [2.x] Fix warnings. Set explicit scalaVersion (#1687)
• fix: [2.x] Update scala 2 bug url (#1672)
• fix: [2.x] fix: Accept jrt: URLs in ClasspathFilter.onClasspath (#1706)
• fix: [2.x] fix: Fix IllegalAccessError analyzing Java compiled with --add-exports (#1714)
• fix: [2.x] fix: Fix NPE in loadInnerClass (#1698)
• fix: [2.x] fix: Track transitive supertypes of member-referenced Java types (#1732)
• fix: [2.x] test: Add regression guard for refinement-member modifier stability (#1720)
• fix: avoid private[this]. fix Scala 3 warnings
• fix: ci: Fixes resource generation (#1786)
• fix: fix ZipCentralDir warning
• …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.

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.