Skip to content
CAI
Software that uses CAICheck a score

scala/scala3

63.7

Adequate · 14 November 2026

340.3k

lines of production code

Scala

primary language

6

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add Chocolatey package support for Windows

This change introduces official support for distributing Scala via Chocolatey, starting with the Scala 3.6.0 release. It adds the necessary package templates and scripts in the \pkgs/chocolatey\ directory, including \scala.nuspec\ for package metadata, \chocolateyInstall.ps1\ and \chocolateyUninstall.ps1\ for installation logic (handling zip extraction and shim creation), and an SVG icon. The installation script supports checksum verification via \LAUNCHER\_SHA256\ and includes specific handling for CI installations.

pkgs · high confidence

Add DynamicVariable and NoStackTrace to Scala.js standard library

The Scala.js standard library now includes \scala.util.DynamicVariable\ and \scala.util.control.NoStackTrace\. \DynamicVariable\ provides a binding mechanism using dynamic scope with static scope resolution, implemented via a simple variable to avoid \ThreadLocal\ dependencies. \NoStackTrace\ is a trait for exceptions that suppress stack trace filling for efficiency, with a note that stack trace suppression is disabled in Scala.js as \SystemProperties\ is not supported.

library-js/src/scala/util · high confidence

Add JavaScript-specific ExecutionContext implementation

The \scala.concurrent.ExecutionContext\ trait and its companion object are now available for Scala.js, providing the infrastructure for asynchronous execution in JavaScript environments. The global execution context is implemented via \JSExecutionContext.queue\, and the \parasitic\ execution context is provided for synchronous, trampolined execution to prevent stack overflow. This change introduces the core concurrency primitives required for \Future\ and \Promise\ support on the JavaScript platform.

library-js/src/scala/concurrent · high confidence

Add Scala 3 language feature examples to scaladoc test suite

The scaladoc test suite now includes a comprehensive set of Scala source files demonstrating Scala 3 (Dotty) language features, including union and intersection types, enums, trait parameters, context queries, implied instances, multiversal equality, type lambdas, and structural types. These examples serve as both documentation references and test cases for the scaladoc generation process, ensuring that the tool correctly handles these modern Scala constructs.

sbt-test/sbt-dotty/scaladoc · high confidence

Add Scala 3 type aliases and traits to library-aux

The library-aux module now includes stub definitions for Scala 3's core type system features: \AnyKind\ (the supertype of all types), \Matchable\ (the base trait for pattern matching), and the intersection (\&\) and union (\\|\) type operators. These additions provide the necessary type definitions for code relying on Scala 3's kind-polymorphism and union/intersection type syntax within this auxiliary library.

library-aux · high confidence

Add Scala.js sandbox example

A new Scala.js sandbox project has been added, providing a basic example application that demonstrates a trait and an object with a main method printing to the console.

sandbox/scalajs · high confidence

Add classfile reader infrastructure

The compiler now includes the core infrastructure for reading Java class files, introducing new modules for handling byte-code codecs, defining JVM constants and flags, and providing a data reader for parsing binary class file structures.

compiler/src/dotty/tools/dotc/core/classfile · high confidence

Add internal SemanticDB protocol buffer parsing and serialization support

The compiler now includes a self-contained implementation for parsing and serializing SemanticDB protocol buffer messages within the \dotty.tools.dotc.semanticdb.internal\ package. This change introduces core infrastructure components including \SemanticdbInputStream\ and \SemanticdbOutputStream\ for byte-level I/O, \LiteParser\ for message decoding, and traits like \SemanticdbGeneratedMessage\ and \SemanticdbGeneratedMessageCompanion\ to support generated data models. It also adds utility classes such as \InvalidProtocolBufferException\ for error handling, \MD5\ for hashing, and \WireFormat\ constants, enabling the compiler to read and write SemanticDB data without external dependencies.

compiler/src/dotty/tools/dotc/semanticdb/internal · high confidence

Add per-phase profiling support via -Yprofile-enabled

The compiler now supports per-phase profiling when the -Yprofile-enabled flag is used. This change introduces a new profile package containing utilities for thread management (ExtendedThreadMxBean, ProfiledThreadPool), file I/O (FileUtils), and JSON serialization (JsonNameTransformer) to capture and export performance data for individual compiler phases.

compiler/src/dotty/tools/dotc/profile · high confidence

Added benchmark input files for collection and tuple operations

New input files have been added to the bench-run/inputs directory to support performance testing of various operations. These include inputs for map, zip, take, drop, and tuple split operations, as well as specific tuple operations such as apply, concat, cons, conversions, map, tail, and zip. The files define size parameters (ranging from 0-50 or specific indices) used to drive the benchmarking suite.

bench-run/inputs · high confidence

Compiler benchmarking and resident mode support

The compiler now includes a new \Bench\ main class for running performance benchmarks, allowing users to instantiate multiple compilers and run them sequentially on the same sources to measure elapsed time and report averages. Additionally, a \Resident\ class has been added to support a persistent compiler mode that stays resident between runs, enabling interactive compilation sessions via a REPL-like interface with commands to reset options or quit.

compiler/src/dotty/tools/dotc · high confidence

Enable direct compilation from TASTY files via -from-tasty

The compiler now supports compiling directly from TASTY files using the \-from-tasty\ flag, allowing users to rebuild projects using only the serialized TASTY representation without original source code. This change introduces a new \TASTYCompiler\ and \ReadTasty\ phase that unpickle TASTY trees into compilation units, supporting both individual \.tasty\ files and \.jar\ archives containing TASTY data. A debug utility (\fromtasty.Debug\) is also added to verify that recompilation from TASTY yields identical results to source compilation. This capability is controlled by the \fromTasty\ setting and includes handling for Java TASTY files via the \-Xjava-tasty\ flag.

compiler/src/dotty/tools/dotc/fromtasty · high confidence

Initial implementation of SemanticDB extraction in the Scala 3 compiler

This change introduces the core infrastructure for extracting SemanticDB information directly from the Scala 3 compiler. It adds a new \semanticdb\ package containing compiler phases (\ExtractSemanticInfo\ and \AppendDiagnostics\) that traverse the typed tree to generate \.semanticdb\ files with symbol definitions, occurrences, and diagnostics. The implementation includes utilities for converting compiler constants, diagnostics, and types to the SemanticDB format, as well as a public API for generating SemanticDB text documents programmatically.

compiler/src/dotty/tools/dotc/semanticdb · high confidence

Interactive code snippets with copy, run, and hide/show controls

The Scaladoc documentation now supports interactive code snippets. Users can copy code to the clipboard using a dedicated button, and runnable snippets feature a 'Run' button that opens a Scastie popup for execution. Snippets can also be collapsed or expanded via a show/hide toggle, and included code sections are linked for easy navigation. This functionality is implemented in the scaladoc-js/common module, which introduces new utilities for HTML generation and safe local storage access to support these UI interactions.

scaladoc-js/common · high confidence

Introduce TastyInspector for direct TASTy file inspection

The \tasty-inspector\ module now provides a new API allowing users to inspect TASTy files directly via the \TastyInspector\ object. Users can load and process \.tasty\ files or JARs containing TASTy data using methods like \inspectTastyFiles\ and \inspectTastyFilesInJar\, passing in a custom \Inspector\ implementation to handle the ASTs. This replaces the previous mechanism where the inspector relied on a \tasty\ member, enabling more direct and flexible inspection of compiled code without requiring full source compilation.

tasty-inspector · high confidence

Introduce dedicated Java parsing infrastructure

The compiler now includes a dedicated Java parser and scanner (JavaParsers, JavaScanners, JavaTokens) alongside a new ParserPhase, separating Java source parsing from Scala parsing. This allows the compiler to correctly parse Java language constructs—including records, sealed classes, and annotations—into the Scala AST, enabling Java sources to be compiled alongside Scala code within the same run.

compiler/src/dotty/tools/dotc/parsing · high confidence

Introduce in-compiler macro interpreter and quote caching

The compiler now includes an in-compiler interpreter for metaprogramming constructs (Interpreter.scala), allowing quoted code to be executed directly during compilation rather than only at runtime. This is supported by a new caching mechanism (QuotesCache.scala) that stores unpickled quote trees to avoid redundant work, and a dedicated TASTY string encoding utility (TastyString.scala) to handle the serialization of these trees. These changes enable faster macro expansion and support for runtime-like evaluation within the compiler phase.

compiler/src/dotty/tools/dotc/quoted · high confidence

Introduce new community-build runner and CLI interface

The community build now uses a new Scala-based runner (\CommunityBuildRunner\) and a command-line interface (\Main\) to manage testing, building, publishing, and documentation generation for external projects. This change replaces previous shell-script-based execution with a structured approach that supports both SBT and Mill build tools, allowing users to run specific commands like \build\, \doc\, \run\, or \publish\ on individual or all community projects via the \community-build/run\ task. Also in this area: Community build runner ignores fatal errors during project execution.

community-build/src · high confidence

Introduce sbt incremental compilation integration phases

The compiler now includes new sbt integration phases (\ExtractAPI\ and \ExtractDependencies\) that send API representations and dependency information to sbt for incremental recompilation. This enables sbt to track changes in class APIs and dependencies, improving build performance by only recompiling affected files. The implementation includes utility classes for API serialization and dependency tracking, supporting both Scala and Java sources.

compiler/src/dotty/tools/dotc/sbt · high confidence

Introduce scala.quoted.staging API for runtime macro evaluation

Adds a new \scala.quoted.staging\ package that allows users to evaluate quoted expressions at runtime. The API provides a \Compiler\ trait with a \make\ factory to instantiate a staging compiler using the application's classloader, and exposes \run\ and \withQuotes\ methods to execute quoted code or access a \Quotes\ context outside of macro expansion. This enables dynamic code generation and inspection in REPLs and scripts.

staging · high confidence

Introduce scripting engine for compiling and running Scala scripts

Adds a new scripting execution engine (\dotty.tools.scripting\) that allows the Scala compiler to compile and run \.scala\ files directly. The \Main\ entry point parses arguments to separate compiler flags from script arguments, supports saving compiled output as a standalone JAR (\-save\/\-savecompiled\), and offers a \-compile-only\ mode to skip execution. It handles classpath expansion and path normalization for cross-platform compatibility (Windows/Unix) and sets system properties (\script.path\, \java.class.path\) to provide context to the running script.

compiler/src/dotty/tools/scripting · high confidence

Introduces high-performance, specialized collection utilities for the compiler

The compiler now uses a new set of internal utility collections in \dotty.tools.dotc.util\ to replace standard library equivalents, providing optimized implementations for hash maps and sets. This includes \GenericHashMap\ and \GenericHashSet\ as base classes with specialized subclasses \HashMap\ (using \equals\/\hashCode\) and \EqHashMap\/\EqHashSet\ (using reference equality \eq\/\identityHashCode\). These collections feature a dense packing mode for small sizes to reduce memory overhead and are designed to minimize allocation and improve lookup performance for the compiler's internal data structures.

compiler/src/dotty/tools/dotc/util · high confidence

Migrated using-directives parser to a standalone compiler module

The \//\> using\ directive parser has been extracted from the Scala CLI codebase into a new, shared \directives-parser\ module within the Scala 3 compiler. This module provides a public entry point (\UsingDirectivesParser.parse\) that scans source files for preamble directives, tokenizes them, and returns structured \UsingDirective\ nodes along with diagnostics. This change enables both the Scala 3 compiler (including the REPL and test harness) and Scala CLI to share the same parsing logic and grammar rules for managing dependencies and compiler options via source-file comments.

directives-parser · high confidence

New FromSymbol utility for generating AST trees from symbols

A new \FromSymbol\ object has been added to the \dotty.tools.dotc.quoted.reflect\ package, providing methods to convert compiler symbols (such as classes, types, methods, and values) into their corresponding typed AST trees (\tpd.Tree\). This utility supports generating definitions for class definitions (including handling parents and constructors), type definitions, method definitions, value definitions, and pattern binds, effectively bridging the gap between symbol information and the abstract syntax tree representation within the quoted reflection system.

compiler/src/dotty/tools/dotc/quoted/reflect · high confidence

New REPL implementation with dependency resolution and improved rendering

The REPL has been replaced with a new implementation that supports adding library dependencies via the \:dep\ command and \//\> using dep\ directives, resolving them through Coursier. It features a new JLine-based terminal with syntax highlighting, history, and improved Ctrl-C handling, along with a new \Rendering\ engine that uses \pprint\ and \fansi\ for better output formatting and bytecode analysis to correctly handle user-defined \toString\ methods. Also in this area: REPL classloader now supports Java version-specific bytecode loading.

repl/src · high confidence

New SBT integration interfaces for incremental compilation callbacks and progress tracking

The compiler now exposes two new interfaces in the \dotty.tools.dotc.sbt.interfaces\ package to support integration with the Zinc incremental compiler. \IncrementalCallback\ provides a set of default methods for reporting API analysis, dependency tracking, and phase completion events, allowing the build tool to receive detailed incremental compilation data. \ProgressCallback\ introduces cooperative cancellation and progress reporting capabilities, enabling the build system to monitor compilation status and request early termination if needed.

compiler/src/dotty/tools/dotc/sbt/interfaces · high confidence

New Scala 2 unpickler infrastructure for reading pickled symbols

The compiler now includes a new set of core classes in the \unpickleScala2\ package to handle reading Scala 2 pickled symbol tables. This adds \PickleBuffer\ for low-level byte array operations, \PickleFormat\ defining the constants and structure of the Scala 2 pickle format, \Scala2Flags\ mapping Scala 2 compiler flags, \Scala2Erasure\ for handling Scala 2-specific type erasure and intersection types, and \Scala2Unpickler\ which orchestrates the deserialization of symbols, types, and annotations from Scala 2 classfiles into the Scala 3 compiler's internal representation. Also in this area: Compiler stability and determinism improvements.

compiler/src/dotty/tools/dotc/core/unpickleScala2 · high confidence

New Scala.js compiler transform phases for JS interop and testing

The compiler now includes several new Scala.js-specific transformation phases in the \transform.sjs\ package to handle JavaScript interoperability and testing infrastructure. \ExplicitJSClasses\ makes inner, local, and exposed JS classes explicit by generating synthetic fields and getters, while \AddLocalJSFakeNews\ inserts fake constructor calls for local JS classes to support runtime class value creation. \PrepJSInterop\ performs essential checks and generates export forwarders for JS exports, and \JUnitBootstrappers\ generates bootstrapper objects for JUnit tests to enable test discovery and invocation without runtime reflection.

compiler/src/dotty/tools/dotc/transform/sjs · high confidence

New TASTY-based decompiler for inspecting compiled Scala code

The compiler now includes a new decompiler tool (invoked via \dotc -decompiler\) that reconstructs a high-level textual representation of Scala code from TASTY files. This feature allows users to inspect the internal structure of compiled code by printing decompiled trees to standard output or saving them to a \decompiled.scala\ file in a specified output directory, facilitating debugging and understanding of the compiler's internal representation.

compiler/src/dotty/tools/dotc/decompiler · high confidence

New benchmark runner with configurable JMH execution

The \bench-run\ module now includes a new \Main.scala\ entry point that wraps the JMH benchmarking framework. This tool allows users to run benchmarks by specifying warmup iterations, measurement iterations, and fork counts via command-line arguments. It supports filtering benchmarks using a regular expression, loading parameter values from input files, and exporting results to CSV format, providing a more flexible and configurable way to execute benchmarks compared to previous methods.

bench-run/src/main/scala/dotty/tools/benchmarks · high confidence

New developer tooling and validation scripts for compiler maintenance

This change introduces a suite of new scripts in \project/scripts\ to support compiler development and documentation maintenance. The \bisect.scala\ script provides an automated way to identify regressions by bisecting nightly releases and commits, supporting validation via compilation, execution, or custom scripts. The \checkErrorCodeSnippets.scala\ script validates that error code documentation examples correctly reproduce the expected compiler errors, while \checkSidebarDocs.scala\ ensures the documentation sidebar remains synchronized with the actual markdown files. Additionally, \addToBackportingProject.scala\ automates the addition of merged pull requests to the appropriate backporting projects via the GitHub GraphQL API, and new shell scripts (\cmdTests\, \bootstrappedOnlyCmdTests\, \cmdScaladocTests\) standardize command-line interface testing for the compiler, scaladoc, and bootstrapped builds.

project/scripts · high confidence

New expression compiler for runtime debug evaluation

The compiler now includes a dedicated ExpressionCompiler module that enables the evaluation of arbitrary Scala expressions at runtime, powering debug consoles in IDEs like Metals and IntelliJ. This feature introduces a new compilation pipeline with three phases: InsertExpression (which injects the user's expression into the source tree at breakpoints), ExtractExpression (which transforms the typed expression and handles access to local variables, private members, and captured values via reflection), and ResolveReflectEval (which resolves reflection calls to actual method/field access). A public ExpressionCompilerBridge class allows external tools to trigger this compilation, generating class files that can be loaded by the running program to compute evaluation results.

compiler/src/dotty/tools/debug · high confidence

New interactive compiler API for IDE integration

The \compiler/src/dotty/tools/dotc/interactive\ package now provides a dedicated API for IDEs to interact with the compiler. This includes \InteractiveDriver\ for managing compilation runs and source files, \Interactive\ for querying typed trees (such as finding references, definitions, and symbol matches), and \Completion.scala\ for code completion logic. Additionally, \LogicalPackagesProvider\ and related classes enable parsing source paths to build a logical package structure, allowing IDEs to resolve symbols and perform completions across multiple source files without relying on the file system layout. Also in this area: Compiler behavior changes for inline method overrides and classpath resolution. Also in this area: 2 commits (1 fix) modifying compiler.

compiler/src/dotty/tools/dotc/interactive · medium confidence · unverified

New safe initialization checker phase

The compiler now includes a new \initChecker\ phase that analyzes object initialization to detect unsafe access patterns. This phase is controlled by the \Whas.safeInit\ and \YsafeInitGlobal\ settings and introduces a co-inductive caching mechanism to ensure the analysis terminates. It provides detailed, trace-based error reporting that highlights the exact sub-expressions and source locations involved in initialization violations, improving the diagnostic experience for users relying on safe initialization guarantees.

compiler/src/dotty/tools/dotc/transform/init · high confidence

New search interface and styling for Scaladoc

The Scaladoc UI now includes a new search bar component with dedicated CSS for layout, loading animations, and dropdown version selection, alongside updated styles for social links and contributors sections. This change introduces the visual structure for the search experience, including result rows and footer elements, while also adding tests to validate the underlying search engine's query parsing and matching logic.

scaladoc-js · high confidence

New source-code and extractor printers for quoted reflections

The compiler now includes new printer implementations in \scala.quoted.runtime.impl.printers\ that allow quoted code to be rendered back into human-readable source code. \SourceCode.scala\ provides a \SourceCodePrinter\ that formats trees, types, and constants with syntax highlighting (supporting both ANSI terminal colors and plain text modes via the \SyntaxHighlight\ trait) and full name resolution. \Extractors.scala\ introduces an \ExtractorsPrinter\ that outputs a structural, extractor-style representation of AST nodes (e.g., \Ident("name")\, \Apply(fun, args)\), which is useful for debugging and testing macros. These changes enhance the ability to inspect and display quoted expressions in their original source form.

compiler/src/scala/quoted/runtime/impl/printers · high confidence

New utility utilities for position handling and term name inference

The presentation compiler now includes two new utility files: \InteractiveEnrichments.scala\ and \TermNameInference.scala\. \InteractiveEnrichments\ provides extension methods for \InteractiveDriver\, \SourcePosition\, \Span\, and \Symbol\ to improve position calculation (including handling tabs and backticks), symbol name formatting, and type dealiasing. \TermNameInference\ adds helpers to generate variable names based on desired types, supporting single-letter, short, and full-name streams. These changes enhance the internal robustness of the presentation compiler's interaction with source code positions and symbol information.

presentation-compiler/src/main/dotty/tools/pc/utils · high confidence

Repl extracted as a standalone artifact with JSR-223 support

The REPL has been extracted into its own module, making it a distinct build artifact. This change introduces JSR-223 scripting engine support, allowing the Scala REPL to be invoked via the standard javax.script API (as evidenced by the new ScriptEngineFactory registration and test resources). Additionally, a new ConsoleInterface class in the sbt-bridge provides a Java entry point to run the REPL driver with custom classpaths, initial/cleanup commands, and variable bindings.

(repo-wide) · high confidence

Scala.js standard library now supports WebAssembly with specialized array builders

The Scala.js standard library in the \scala.collection.mutable\ package has been updated to support linking with minimal WebAssembly modules. This change introduces platform-specific implementations for collection builders, such as \ArrayBuilder\, which now uses runtime checks to select a specialized, type-optimized builder for WebAssembly targets while maintaining a generic JavaScript-optimized path for JS targets. This allows users building for WebAssembly to benefit from better performance and smaller binary sizes for mutable collections.

library-js/src/scala/collection/mutable · high confidence

Scaladoc documentation and static assets added

The scaladoc module now includes a README and design documentation explaining its three-module structure (scaladoc, scaladoc-js, scaladoc-testcases) and core pipeline. Additionally, static resources such as the Scaladoc logo, banner icons (error, info, neutral, success, warning), and theme-specific bulb icons have been added to support the documentation site's UI. Also in this area: 1 commit adding/updating tests in scaladoc, scaladoc-testcases; Interactive toggle for capture checking syntax in Scaladoc; Add Scala 3 language feature examples to scaladoc test suite.

scaladoc · high confidence · unverified

Support for Best Effort TASTy format in public APIs

The compiler now exposes the Best Effort TASTy format through the \dotty.tools.tasty\ package, allowing external tools to read and write TASTy files that may contain compilation errors. This includes the \BestEffortTastyFormat\ object, which defines the specific header bytes (\0x5C, 0xA1, 0xAB, 0x20\) and the new \ERRORtype\ AST tag, as well as the \BestEffortTastyHeaderUnpickler\ class, which handles parsing these files and validating their version compatibility against the current compiler.

compiler/src/dotty/tools/tasty · high confidence

Support for Mirrors on local and inner classes

The compiler now supports generating derivation Mirrors for local and inner classes, allowing users to summon Mirror instances for types defined within other classes or methods. This enables compile-time reflection capabilities for nested type structures that were previously unsupported.

i13332, sbt-test/scala2-compat/i13332 · high confidence

Support for pattern matching on Java records

Users can now destructure Java records directly in Scala pattern matching expressions. This change enables matching against standard records, generic records, and records with explicit or vararg constructors, allowing seamless interoperability when working with Java record types in Scala code.

sbt-test/pipelining/Xjava-tasty-record-match/a, sbt-test/pipelining/Xjava-tasty-record-match/b · high confidence

Removals

Removal of sbt-dotty plugin and associated test suites

The sbt-dotty plugin has been removed from the project. This change eliminates the legacy Dotty (Scala 3) support infrastructure, including the \DottyInjectedPlugin\ and the \sbt-dotty\ test suite (which contained examples for compiler plugins, quoted code, and TASTy inspection). It also removes the \scala2-compat\ and \source-dependencies\ test suites, which were previously used to verify compatibility and incremental compilation behavior.

(repo-wide) · high confidence

API

New compiler interface contracts for diagnostics, source files, and callbacks

The public compiler interface now exposes a set of new Java interfaces that allow external tools to interact with the compilation process more precisely. Users can now receive structured diagnostic messages via the \Diagnostic\ interface, which includes support for related information through \DiagnosticRelatedInformation\ and optional source positions via \SourcePosition\. Source file content is accessible through the \SourceFile\ interface, which provides both \content()\ (deprecated) and \textContent()\ methods. Additionally, the \CompilerCallback\ interface enables users to hook into compilation events such as class generation and source compilation completion, while \SimpleReporter\ and \ReporterResult\ provide mechanisms to handle and summarize diagnostic output.

interfaces · high confidence

Architecture

Introduce dedicated capture-checking state and capability infrastructure

The compiler now uses a dedicated \CCState\ class to manage capture-checking context, replacing previous global or ad-hoc state management. This state tracks iteration counts, separation-checking flags, and caches for use sets and local capability classifiers. A new \Capability\ hierarchy has been introduced, defining root capabilities (like \GlobalAny\ and \GlobalFresh\), core capabilities (like \ObjectCapability\ and \SetCapability\), and derived capabilities (such as \ReadOnly\, \Maybe\, and \Classified\). Additionally, a new \CaptureAnnotation\ type simulates \@retains\ annotations but supports capture set variables and a boxed status, enabling more efficient and precise tracking of captured references during the capture checking phase.

compiler/src/dotty/tools/dotc/cc · high confidence

Introduction of the Desugar module for AST transformation

The compiler now includes a new \Desugar.scala\ file in the \ast\ package that centralizes the logic for transforming untyped trees into typed structures. This module defines attachment keys for tracking the origin of various language constructs, such as \DerivingCompanion\ for classes with \derives\ clauses, \UntupledParam\ for parameter untupling, and \ContextBoundParam\ for context bound evidence. It also introduces specific checks like \CheckIrrefutable\ for pattern definitions and generators, and handles multi-line infix operations to improve error explanations. This change represents a structural reorganization of the compiler's desugaring phase, moving complex tree manipulation logic into a dedicated component. Also in this area: Compiler stability and determinism improvements; Parallelized JVM backend classfile generation and writing.

compiler/src/dotty/tools/dotc/ast · high confidence

JVM optimizer code moved to dedicated opt package

The JVM backend optimizer components have been reorganized into a new \dotty.tools.backend.jvm.opt\ package. This change introduces new files such as \BCodeRepository\ for caching and reading bytecode from the classpath, \BTypesFromClassfile\ for constructing type information from parsed class files, and \FifoCache\ for thread-safe LRU caching. It also includes \OptimizerSettings\ to encapsulate compiler settings without capturing the global \Context\, and utility objects like \MethodMax\ for computing stack/locals and \Limits\ for optimization thresholds. This refactoring isolates optimizer-specific logic and improves modularity within the JVM backend.

compiler/src/dotty/tools/backend/jvm/opt · high confidence

Move generated SemanticDB source files into a dedicated directory

The generated Scala source files for the SemanticDB protocol buffer messages (including Annotation, Location, Scope, Synthetic, TextDocument, and TextDocuments) have been moved into the \compiler/src/dotty/tools/dotc/semanticdb/generated\ directory. This change reorganizes the compiler's internal structure to separate these auto-generated protocol definitions from other compiler sources, improving codebase organization without altering the semantic functionality of the SemanticDB integration.

compiler/src/dotty/tools/dotc/semanticdb/generated · high confidence

Presentation compiler refactored into new provider classes

The presentation compiler implementation in \presentation-compiler/src/main/dotty/tools/pc\ has been restructured into a set of dedicated provider classes, including \AutoImportsProvider\, \CachingDriver\, \CompilerSearchVisitor\, \CompletionItemResolver\, \ConvertToNamedArgumentsProvider\, \DiagnosticProvider\, \ExtractMethodProvider\, \HoverProvider\, \InferExpectedType\, \MetalsInteractive\, and \PcConvertToNamedLambdaParameters\. This change introduces a caching mechanism for the compilation driver to skip redundant compilations when file content and URI remain unchanged, adds support for converting wildcard lambda parameters to named ones, and refactors hover, completion, and auto-import logic into modular components.

presentation-compiler/src/main/dotty/tools/pc · high confidence

Refactored inlining infrastructure into modular components

The compiler's inlining logic has been reorganized from a monolithic structure into distinct, focused modules: \Inlines.scala\ now handles the detection and decision-making for which calls to inline, \Inliner.scala\ manages the core tree transformation and context mapping during expansion, \InlineReducer.scala\ is responsible for optimizing the inlined code (such as reducing projections and match expressions), and \PrepareInlineable.scala\ deals with generating accessors for private members accessed from inlined code. This structural change improves maintainability and separation of concerns within the compiler's inlining phase.

compiler/src/dotty/tools/dotc/inlines · high confidence

Behavioural changes

11 commits (1 fix) modifying compiler/src/dotty/tools/backend/jvm/analysis

A change to existing behaviour in compiler/src/dotty/tools/backend/jvm/analysis — 11 commits (1 fix), 7 files: “Use \mutable.{Map,Set}\ everywhere, remove \util.Hash{Map,Set}\ (\#27252)”; “Optimizer: bound producer/consumer analysis cost in local optimizations (\#27290)”; “Simplify or avoid some data copies (\#26826)”; and 8 more (refs \#27252, \#27290, \#26826, \#26174, \#25828, …).

compiler/src/dotty/tools/backend/jvm/analysis · medium confidence · unverified

13 commits (3 fixes) modifying compiler/src/dotty/tools/dotc/coverage

A change to existing behaviour in compiler/src/dotty/tools/dotc/coverage — 13 commits (3 fixs), 1 file: “Coverage: unescape when deserializing (\#27127)”; “Add in initial support for code coverage”; “Make coverage support incremental compilation (\#24773)”; and 10 more (refs \#27127, \#24773, \#15791, \#15384, \#26795, …).

compiler/src/dotty/tools/dotc/coverage · medium confidence · unverified

2 commits (1 fix) modifying sbt-test/sbt-dotty/dump-sbt-inc

A change to existing behaviour in sbt-test/sbt-dotty/dump-sbt-inc — 2 commits (1 fix), 3 files: “Use \mutable.{Map,Set}\ everywhere, remove \util.Hash{Map,Set}\ (\#27252)”; “Fix behavior of \-Ydump-sbt-inc\ (\#25125)” (refs \#27252, \#25125).

sbt-test/sbt-dotty/dump-sbt-inc · medium confidence · unverified

30 commits (1 fix) modifying compiler/src/dotty/tools

A change to existing behaviour in compiler/src/dotty/tools — 30 commits (1 fix), 1 file: “Remove unused imports”; “Tweak: Avoid type ascription in uncheckedNN”; “Add explicit return types to public members”; and 27 more (refs \#26794, \#25937, \#26239, \#26426, \#24920).

compiler/src/dotty/tools · medium confidence · unverified

83 commits (13 fixes) modifying compiler/src/dotty/tools/backend/sjs

A change to existing behaviour in compiler/src/dotty/tools/backend/sjs — 83 commits (13 fixs), 5 files: “Partial fix for lampepfl\#7113: Fix Scala.js codegen for Explicit Returns”; “merge upstream (Nullability Analysis without NotNull \#7556)”; “Foundations for the optimizer & cleanup (\#25187)”; and 80 more (refs \#7556, \#25187, \#15701, \#10563, \#17582, …).

compiler/src/dotty/tools/backend/sjs · medium confidence · unverified

86 commits (21 fixes) modifying presentation-compiler/src/main/dotty/tools/pc/completions

A change to existing behaviour in presentation-compiler/src/main/dotty/tools/pc/completions — 86 commits (21 fixs), 12 files: “Address review comments”; “Improve signature help by more stable position calculation + better named arg support (\#19214)”; “fix: StringIndexOutOfBoundsException in presentation compiler's hasColon method (\#23498)”; and 83 more (refs \#19214, \#23498, \#23356, \#26113, \#21592, …).

presentation-compiler/src/main/dotty/tools/pc/completions · medium confidence · unverified

Added Apache License 2.0 text to distribution

The distribution package now includes a LICENSE.rtf file containing the full text of the Apache License, Version 2.0, ensuring that end-users receive the required license terms with the software.

dist · high confidence

Added placeholder file to out directory

A new .keep file has been added to the out directory to ensure the directory is tracked by version control, preventing it from being ignored or removed during fresh clones.

out · medium confidence

Classpath implementation refactored with new entry types and caching

The compiler's classpath handling has been restructured to improve performance and correctness. A new \AggregateClassPath\ unifies multiple class- and sourcepath entries, using a package index to optimize lookups. The core \ClassPath\ trait now uses \BinaryFileEntry\, \SourceFileEntry\, and \BinaryAndSourceFilesEntry\ to represent classpath entries, allowing the compiler to distinguish between binary and source files and merge them when both exist. \ClassPathFactory\ centralizes the creation of classpath instances, supporting logical source paths and manifest-based JAR classpaths. Directory and JAR lookups are now handled via \DirectoryLookup\ and \ZipArchiveFileLookup\ traits, with \FileBasedCache\ providing file-stamp-based caching for JARs to avoid stale metadata. These changes reduce allocations and IO calls, speed up classpath aggregation, and ensure stable ordering of directory entries. Also in this area: Compiler behavior changes for inline method overrides and classpath resolution.

compiler/src/dotty/tools/dotc/classpath · high confidence

Community build project submodules updated

The community-build/community-projects directory has been refreshed with new submodule commits for a wide range of external Scala libraries and tools, including Akka, Cats, Cats-Effect, fs2, http4s, Monocle, ScalaTest, ZIO, and many others. This ensures the managed community build tests against the latest upstream versions of these dependencies.

community-build/community-projects · high confidence

Compiler core refactoring and stability fixes

The compiler core in \compiler/src/dotty/tools/dotc/core\ has undergone extensive refactoring to improve stability and performance. Key changes include removing the \Context\#clone\ method and migrating to a new context management scheme, optimizing type comparison and constraint handling logic, and fixing various bugs related to cyclic references, type inference, and capture checking. These updates enhance the robustness of the type system and reduce allocation overhead during compilation. Also in this area: Refined capability projection logic and enabled capture-checking in standard library; Classpath API refactoring and inline method retention fix; Interactive toggle for capture checking content in Scaladoc; Fix StopRepl loading in local interrupt instrumentation mode; Support for self-based type class derivation; and 35 more.

compiler/src/dotty/tools/dotc/core, repository · medium confidence

Compiler reporting subsystem refactored to use a new Diagnostic and Message architecture

The compiler's error and warning reporting system has been restructured to use a new \Diagnostic\ type (replacing the previous \MessageContainer\) and a structured \Message\ class, enabling richer error information such as unique error IDs (\ErrorMessageID\), structured related information for inline call-sites, and actionable code fixes (\CodeAction\). This change introduces a new \AbstractReporter\ base class and refactors \ConsoleReporter\ to better handle prompts and output, while also enhancing 'did you mean' suggestions via \DidYouMean\ and improving message rendering with \MessageRendering\. Users will see more consistent, ID-tagged error messages, better inline trace explanations, and potential for tooling integration via the new structured diagnostic interface. Also in this area: Compiler stability and determinism improvements.

compiler/src/dotty/tools/dotc/reporting · high confidence

Compiler transform phase logic and bug fixes

The compiler's transform phases have been updated with numerous bug fixes and behavioral adjustments, including corrections to pattern matching (handling by-name arguments, union types, and generic tuples), erasure (preserving Java varargs, handling erased context functions, and fixing bridge generation), and inlining (beta-reduction, outer select handling, and tailrec optimization). Specific fixes address crashes in SAM conversion, macro splicing, and lazy val initialization, while also refining unused code warnings and coverage instrumentation logic within the transform pipeline.

compiler/src/dotty/tools/dotc/transform · medium confidence

Deprecation of legacy collection and conversion APIs

The standard library deprecates several legacy APIs to encourage migration to modern equivalents. \JavaConverters\ is deprecated in favor of \CollectionConverters\ (and its sub-packages like \javaapi\), and \scala.compat.Platform\ is deprecated. Additionally, various collection methods and internal implementation details, such as \Buffer\#trimStart\/\trimEnd\, \NonLocalReturns\, and specific \TrieMap\ internals, are marked for deprecation to streamline the API surface.

library · high confidence

Detect missing class file for classpath dependency in macro

The compiler now detects when a macro expansion requires a class file that is not yet available on the classpath (e.g., because the dependency is pipelined and only an early-output jar exists). Instead of failing silently or producing incorrect results, the compiler aborts macro expansion with a clear error, ensuring that users are notified of the missing dependency rather than encountering obscure compilation issues later.

sbt-test/pipelining/pipelining-scala-macro-splice-ok/m, sbt-test/pipelining/pipelining-scala-macro-splice/a, sbt-test/pipelining/pipelining-scala-macro-splice/m · high confidence

Enable strict equality pattern matching by default

The compiler now enables strict equality pattern matching (SIP-67) by default. This change tightens the rules for pattern matching, requiring that the types being matched are compatible in a stricter sense, which helps catch potential runtime errors earlier during compilation. Also in this area: Compiler behavior changes for inline method overrides and classpath resolution; Compiler stability and determinism improvements; Parallelized JVM backend classfile generation and writing; Generic number literals are now behind a feature flag.

compiler/src/dotty/tools/dotc/typer · high confidence

Incremental compilation now tracks synthesized mirrors

The compiler's incremental compilation engine has been updated to recognize and track changes to synthesized mirrors. This ensures that when a case class or sealed trait hierarchy is modified (such as adding fields or new subclasses), the build system correctly identifies dependent code that requires recompilation, preventing stale artifacts from being used.

mirror-product, mirror-sum · high confidence

Introduce TASTy versioning and compatibility checks

The TASTy format now includes explicit major, minor, and experimental version numbers in the file header, enabling the compiler to validate compatibility between compiled libraries and the current tool. This change introduces a \TastyVersion\ model and logic in \TastyHeaderUnpickler\ to enforce backward compatibility (requiring recompilation if the library was built with a newer major version or a newer stable minor version) and forward compatibility (requiring an upgrade of the compiler if the library was built with a newer minor version). Experimental versions are handled strictly, allowing an experimental compiler to read only final TASTy files from previous minor versions, while final compilers cannot read experimental TASTy files. This ensures that incompatible TASTy files are rejected with clear error messages guiding users to either recompile their dependencies or upgrade their compiler.

tasty · high confidence

Introduce libexec folder in the distribution

The distribution now includes a new \libexec\ directory containing platform-specific shell scripts (for Bash and Windows batch) that handle Java environment detection, path resolution, and terminal settings. These scripts centralize the logic for locating the Java executable, managing \JAVA\_HOME\, and configuring terminal I/O (including a fix to prevent \stty\ errors when not running in a terminal), providing a consistent foundation for launching Scala CLI tools across different operating systems.

dist/libexec · high confidence

Introduce new compiler printing infrastructure

The compiler's printing subsystem has been restructured with the introduction of new core components: a \Show\ typeclass system for type-safe value representation, a \StringFormatter\ for context-aware string interpolation, a \Highlighting\ module for ANSI color support, and a \MessageLimiter\ to prevent infinite recursion during error reporting. This refactoring replaces the previous ad-hoc string concatenation approach with a more robust, composable, and context-aware printing architecture, improving the reliability and consistency of compiler output, error messages, and REPL interactions.

compiler/src/dotty/tools/dotc/printing · high confidence

Introduce new plugin architecture with Standard and Research plugins

The compiler plugin system has been restructured to support two distinct plugin types: StandardPlugin and ResearchPlugin. Standard plugins now use an \initialize\ method that accepts an implicit Context (replacing the deprecated \init\ method) to return a list of phases to be inserted into the compilation pipeline. Research plugins, which are only supported in nightly or snapshot builds, can freely customize the entire phase plan via their \init\ method. The plugin loading mechanism now relies on a \plugin.properties\ file for descriptor lookup instead of XML files, and includes logic to handle ordering constraints and prevent duplicate plugin names.

compiler/src/dotty/tools/dotc/plugins · high confidence

JVM backend primitive operation handling refactored

The JVM backend's handling of Scala primitive operations (such as arithmetic, comparisons, and array access) has been restructured. The primitive operation codes are now defined as \inline val\s in \ScalaPrimitivesOps\, and the logic for mapping symbols to these codes is consolidated in a new \ScalaPrimitives\ class within the \dotty.tools.backend\ package. This change replaces the previous implementation located in \scala.tools.nsc\, optimizing allocation and reducing context captures to improve compilation performance.

compiler/src/dotty/tools/backend · high confidence

JVM backend refactored into new source files

The JVM backend code in \compiler/src/dotty/tools/backend/jvm\ has been reorganized into new source files (BCodeBodyBuilder, BCodeHelpers, BCodeIdiomatic, BCodeSkelBuilder, BCodeSyncAndTry, BCodeUtils, BTypeLoader). This change moves the implementation of bytecode generation logic into these specific components without altering the external behavior of the compiler.

compiler/src/dotty/tools/backend/jvm · high confidence

JavaScript runtime library adds JS-specific runtime support and VarArgsBuilder

This change introduces new Scala.js-specific runtime files in the standard library to support linking with minimal WebAssembly modules. It adds a JS-specific \VarArgsBuilder\ that uses JavaScript arrays for non-Wasm targets and generic object arrays for Wasm, and provides JS-specific implementations of \BoxesRunTime\ (including \equals\ logic that handles NaN and strict equality) and \ScalaRunTime\ (covering array operations, hashing, and product support).

library-js/src/scala/runtime · high confidence

New Scaladoc search engine with Inkuire integration and recent queries

The Scaladoc JavaScript frontend now features a completely rewritten search system. It introduces a new \PageSearchEngine\ for local page indexing and integrates with the external \Inkuire\ search engine for signature matching, allowing users to search by name, kind (e.g., class, trait), or signature. The search bar now supports recent queries stored in local storage, groups results by kind, and provides a 'Load more' pagination mechanism. Additionally, the version dropdown handler has been refactored to use a global \Globals\ object for configuration and includes logic to verify link validity before navigation.

scaladoc-js/main · high confidence

New \`scala\` launcher bundles Scala CLI and replaces legacy runner

The distribution now includes new \dist/bin/scala\ and \dist/bin/scala.bat\ scripts that act as a launcher for the bundled Scala CLI (\scala-cli\/\scala-cli.exe\). These scripts detect the installed Scala version, configure the Maven repository, and invoke the CLI with \--skip-cli-updates\ and the default version, providing a unified entry point for running Scala code. This complements the refactored \scalac\ and \scaladoc\ binaries, which now explicitly target \dotty.tools.MainGenericCompiler\ and \dotty.tools.scaladoc.Main\ respectively, while the new \scala\ command shifts the runtime execution model to the embedded CLI tool.

dist/bin · high confidence

Optimized string interpolation and for-comprehension transformations

The compiler now includes new local optimization phases that improve performance and correctness for common Scala patterns. String interpolators (\s\, \raw\, and \f\) are transformed into more efficient string concatenation or \StringOps.format\ calls at compile time, bypassing the standard \StringContext\ overhead. Additionally, a new phase drops unused trailing \map\ calls in for-comprehensions when the result type remains unchanged, and a format checker validates \f\-interpolator arguments to provide better error reporting and linting warnings for type mismatches.

compiler/src/dotty/tools/dotc/transform/localopt · high confidence

Port Scala.js standard library to Scala 3

The Scala.js standard library implementation has been ported to Scala 3, introducing new source files for core types such as \App\, \Array\, \Console\, \Enumeration\, \MatchError\, \Symbol\, and \ClassTag\. This migration includes the official deprecation of the \scala.App\ trait in Scala 3, the adoption of the \scala.language.2.13\ import for compatibility, and the replacement of the JVM-based \UniquenessCache\ with a Scala.js-specific implementation using \js.Dictionary\.

library-js/src/scala · high confidence

Re-architecture of quote pickling and scope tracking

The internal implementation of the Quotes API has been re-architected to improve scope tracking and error reporting for macros. New classes \ExprImpl\, \TypeImpl\, \SpliceScope\, \ScopeException\, and \ExprCastException\ replace previous mechanisms, introducing explicit scope tracking for splices to detect scope extrusion errors (using code created outside its defining splice) with detailed diagnostic messages. The \QuotesImpl\ object now serves as the central implementation, wiring these components together and providing the \show\, \matches\, \valueOrAbort\, and \asExprOf\ extension methods on \Expr\.

compiler/src/scala/quoted/runtime/impl · high confidence

Refactored command-line argument parsing and help display infrastructure

The compiler's command-line interface has been restructured to improve how options are parsed, validated, and displayed. A new \CommandLineParser\ object now handles shell-convention tokenization (including quote handling) and \@file\ argument expansion, replacing previous ad-hoc logic. The \CliCommand\ trait centralizes help message generation, introducing categorized usage views (standard, verbose, warning, advanced, private) and a \Columnator\ for formatted two-column output. \CompilerCommand\ now routes help requests (\-help\, \-Vhelp\, \-Xhelp\, etc.) through this unified system, ensuring consistent formatting and better handling of option aliases and deprecation notices in the help output.

compiler/src/dotty/tools/dotc/config · high confidence

Refactored staging phase with explicit type healing and level tracking

The compiler's staging phase has been restructured to improve how it handles cross-stage references and type healing. A new \StagingLevel\ module now explicitly tracks quotation depth via context properties, replacing previous mutable state approaches. The \CrossStageSafety\ transformer has been split out to handle level consistency checks and type healing logic, which now automatically summons \quoted.Type\[T\]\ tags for locally defined types used at higher staging levels. Additionally, \QuoteTypeTags\ manages the collection of these tags, and \TreeMapWithStages\ provides a base for tree transformations that correctly update symbol level information. This refactoring ensures that ill-staged references are either healed or reported with clearer errors, while keeping the transformation artifacts hidden from macro users.

compiler/src/dotty/tools/dotc/staging · high confidence

Replaced legacy build scripts with sbt-native-packager wrappers

The \bin\ directory has been restructured to replace the previous \dotc\/\dotr\ scripts with new wrappers (\scalac\, \scala\, \scaladoc\, \replQ\, etc.) that delegate to artifacts produced by \sbt-native-packager\. Common logic for detecting source changes and triggering rebuilds is now centralized in \bin/common\, while platform-specific distribution paths are handled by \bin/common-platform\. A new \bin/commonQ\ and associated \\*Q\ scripts (e.g., \scalacQ\, \scalaQ\) support running the non-bootstrapped compiler directly from the classpath generated by \sbt buildQuick\, enabling faster iteration for developers.

bin · high confidence

Repository governance and infrastructure baseline established

The repository now includes foundational configuration files that define how the project is built, maintained, and contributed to. This includes a comprehensive .gitignore to prevent build artifacts and IDE files from being tracked, .gitattributes to ensure consistent line endings across platforms, and .jvmopts to set default JVM memory and stack size parameters for the build process. Additionally, the project has adopted the Apache 2.0 license, established a Code of Conduct, and introduced an LLM usage policy to regulate AI-assisted contributions, alongside detailed contributing and security guidelines for developers.

(repo-wide) · high confidence

Rewrite compiler IO layer to use Java NIO

The compiler's internal file system abstraction (dotty.tools.io) has been rewritten to use Java NIO (java.nio.file) instead of the legacy java.io.File API. This change introduces new core types such as Path, File, Directory, and AbstractFile, and replaces the previous implementation to improve path handling, support for virtual files, and JAR archive management. Users benefit from more robust file operations, better cross-platform path resolution, and improved performance in file I/O hot paths.

compiler/src/dotty/tools/io · high confidence

Scala.js 1.19 compatibility and internal library adjustments

This update aligns the Scala.js standard library with Scala.js 1.19, introducing \AnonFunctionXXL\ as a deprecated abstract class to support IR deserialization patches for legacy code compiled against earlier versions. It also adds \UnitOps\ to manage implicit scope for \scala.Unit\ under Scala.js, while reverting previous changes to this implicit scope handling to fix specific behavioral issues.

library-js/src/scala/scalajs · medium confidence

Scala.js standard library: LazyList concurrency and documentation updates

The Scala.js standard library now includes platform-specific base classes for LazyList and LazyListIterable that replace synchronized blocks with lock-free atomic operations (compareAndSet/getAndSet) for tail updates, improving concurrency performance on the JavaScript platform. Additionally, Scaladoc comments across the immutable collection package have been standardized to use Markdown syntax, and missing @param, @tparam, and @return tags have been filled in to improve documentation completeness.

library-js/src/scala/collection/immutable · high confidence

Stabilized Scala compiler settings for pipelining and TASTy interoperability

Several Scala compiler settings previously marked as experimental have been stabilized, enabling more robust support for pipelining and TASTy-based interoperability. This includes improved handling of inline definitions in Scala, reading Java annotations and enums via TASTy, and better type compatibility when Scala code interacts with Java classes (such as handling \Object\ types, generic classes, and result types). These changes allow developers to rely on these features in production builds without needing experimental flags.

(repo-wide) · high confidence

Support zinc invalidation for type arguments in macro calls

The macro system now correctly handles invalidation when type arguments change, ensuring that recompilation triggers appropriately when the type structure of a macro's generic parameter is modified. This prevents stale compilation artifacts in scenarios involving generic macros with type parameters.

(repo-wide) · high confidence

Switch to CompilerInterface2 for the compiler bridge

The sbt-bridge now registers the Dotty compiler bridge via the new xsbti.compile.CompilerInterface2 service provider interface. This change updates the underlying compiler interface mechanism used by sbt, ensuring compatibility with the CompilerInterface2 standard.

sbt-bridge/resources · high confidence

TASTy format introduces dedicated sections for attributes, comments, and positions

The TASTy binary format has been restructured to store metadata in distinct, named sections rather than embedding them within the main AST tree. This change introduces an Attributes section (handling flags like Java source, explicit nulls, and capture checking), a Comments section (storing docstrings), and a Positions section (storing source spans and line sizes). The compiler now uses dedicated picklers and unpicklers for these sections, allowing tools to access source-level metadata and compilation context independently of the core type and term trees.

compiler/src/dotty/tools/dotc/core/tasty · high confidence

Translate sbt-bridge to Java and add ScalaDoc support

The sbt-bridge implementation in the xsbt package has been rewritten from Scala to Java. This change introduces a new CompilerInterface class to maintain compatibility with older build tools (sbt 1.3.x, Mill, Bloop) by handling classloader validation and fallbacks, and adds new DottydocRunner and ScaladocInterface classes to support ScalaDoc generation via the Dotty compiler.

sbt-bridge/src/xsbt · high confidence

Updated Scaladoc test assets with new Bootstrap CSS and font imports

The static site assets for the scaladoc testcases have been updated to include a new minified Bootstrap CSS file. This stylesheet introduces a new visual theme for the generated documentation, importing the 'Lato' sans-serif and 'Fira Code' monospace fonts from Google Fonts. It also defines a specific color palette using CSS variables, applying a dark slate for the toolbar and sidebar, and a red accent color for active states and secondary elements, ensuring the test documentation renders with the updated styling.

scaladoc-testcases · high confidence

Upgrade sbt-bridge to CompilerInterface2 with enhanced diagnostic and progress support

The sbt-bridge has been upgraded to implement the CompilerInterface2 API, introducing support for structured diagnostics and build progress tracking. Users will now see richer compiler output, including diagnostic codes, explanations, and related information (such as inline call-site chains) forwarded to the build tool. The bridge also introduces cooperative cancellation via CompileProgress callbacks, allowing builds to be interrupted more gracefully. Additionally, new fallback mechanisms for virtual files ensure robustness when source file paths cannot be resolved, and code actions are now exposed through the diagnostic interface.

sbt-bridge/src/dotty · high confidence

XML parsing and code generation moved into the compiler

The XML literal parsing and symbolic builder logic, previously provided by the external scala-xml library, is now implemented directly within the compiler (in \compiler/src/dotty/tools/dotc/parsing/xml\). This change removes the compiler's dependency on scala-xml, allowing XML literals to be processed and transformed into AST trees without requiring the standard library's XML module at compile time.

compiler/src/dotty/tools/dotc/parsing/xml · high confidence

Test coverage

Add Scala 2 compatibility test for NumericRange specialization; Add Scala 2 compatibility test for annotation argument handling; Add Scala 2 compatibility test for constant annotation arguments; Add Scala 2 compatibility test for type parameter unpickling; Add Scala 2 compatibility tests for inaccessible case class constructors; Add Tasty inspector cache test case for issue \#13919; Add analyzer-plugin test suite for Scala 3 compiler tree retention; Add community build test suite for third-party Scala libraries; Add comprehensive presentation compiler completion tests; Add custom analyzer plugin test suite; Add pipelining cancellation test case; Add pipelining integration tests for Java TASTy and incremental compilation; Add sbt test verifying compiler diagnostic codes and quick-fix actions; Add scripted test for compiler reporter deprecation and feature summaries; Add test case for Tasty inspector cache initialization; Add test for TastyInspector inspectTastyFilesInJar; Add test for compiler reporter with Scala 2 unpickling; Add test for divide-by-zero compiler plugin; Add test resources for REPL :jar command; Add tests for presentation compiler definition and type definition features; Added JMH benchmarks for runtime.Tuples operations; Added REPL macro test resources; Added REPL test resources for capture checking and type display; Added Scala 2 compatibility erasure tests; Added Scala 2 compatibility regression test for i16351; Added Scala 2 compatibility test for S3SnapshotStore; Added Scala 2 compatibility tests for standard library components; Added Scala 3 compatibility tests for hierarchical mirrors and macros; Added Scala.js compiler test infrastructure; Added Scala.js erasure compatibility test; Added Scala.js integration tests for basic usage and IR position emission; Added SemanticDB test infrastructure and expect-based validation; Added TASTy compatibility regression tests; Added backward-compatibility tests for Scala 3 mirrors and annotations; Added base test suites for presentation compiler features; Added benchmarks for tuple take, drop, and split operations; Added compiler tests for function/tuple specialization and transformation logic; Added comprehensive test suites for presentation compiler hover functionality; Added debugger integration tests; Added initial JUnit test for HelloTest; Added inlay hints regression tests for inlined dependencies and core hint scenarios; Added integration tests for Scala 3 sbt-bridge; Added negative tests for divide-by-zero detection in research and standard compiler plugins; Added pipeline build tests for Scala and Java files; Added regression test cases for Scaladoc issues i18231 and i20476; Added regression test for Java-Scala compatibility issue i9200; Added regression test for Java-Scala compatibility issue i9200; Added regression tests for Java compatibility edge cases; Added regression tests for presentation compiler crashes and macro behaviors; Added regression tests for scaladoc TastyInspector issues; Added scripted tests for the bin/scalac and bin/scala tools; Added scripting test resources for argument, environment, and path handling; Added scripting test suite for exit codes, script arguments, and expressions; Added semantic token tests for the presentation compiler; Added source-dependency regression tests for Scala 3 incremental compilation; Added test case for opaque type issue \#12927; Added test cases for deep package nesting and complex for-comprehension structures; Added test cases for main class discovery in Scala and Scala.js; Added test coverage for the LineNumberPlugin script wrapper; Added test coverage for typer internals and SIP-67; Added test for Automatic-Module-Name manifest verification; Added test for FailureSummarizer; Added test for NewArrayIssue22794; Added test for Scala 2 compatibility issue i8847; Added test for Scala 3 Java annotation compatibility; Added test for sourcepath with inline definitions; Added test infrastructure and test cases for the Scala parser; Added test suites for compiler reporting and code actions; Added test suites for presentation compiler caching, diagnostics, and selection ranges; Added test suites for presentation compiler code actions and refactoring; Added test suites for signature help edge cases; Added test utilities for presentation compiler validation; Added tests for SBT progress callback and cancellation; Added tests for Scala 2 Ordering compatibility; Added tests for TASTy comment pickling, path handling, and header unpickling; Added tests for command-line parsing, settings, and warning configuration; Added tests for compiler coverage instrumentation and serialization; Added tests for compiler profiling trace generation and file utilities; Added tests for document highlighting in the presentation compiler; Added tests for pattern matching space engine logic; Added tests for presentation compiler symbol information; Added unit tests for AST attachments, desugaring, and tree mapping; Added unit tests for IO package components; Added unit tests for classpath resolution and caching; Added unit tests for compiler core type system and symbol loading; Added unit tests for compiler printing and syntax highlighting; Added unit tests for compiler utility collections and diff utilities; Added unit tests for sbt-bridge incremental compilation and dependency extraction; Added unit tests for the plugin scheduling algorithm; Expanded JVM backend bytecode verification tests; Expanded REPL test coverage for directives, classpath management, and diagnostics; Expanded test coverage for compiler fixes and features; Fix Scala 2 compatibility for implicit parameters in unpickled code; New and refactored compiler test infrastructure; New compiler test infrastructure and utilities; New micro-benchmarks for specialized traits, lazy vals, and type operations; New test exclusion and allowlist files for compiler test suites; New test infrastructure for bytecode verification and test configuration; REPL type-printer test resources added; Regression test for issue i19675; Test suite added for Scala 3.1 anonymous product mirror behavior; Vulpix test framework refactored into modular components.

Dependencies

New sbt build definition and documentation dependencies

The project introduces a new \build.sbt\ file that defines the core Scala 3 build structure, including non-bootstrapped and bootstrapped compiler, library, REPL, TASTy inspector, and distribution modules. Additionally, the \docs/\_spec\ directory now includes a \Gemfile\ and \Gemfile.lock\ specifying Jekyll, Webrick, Rouge, and Jekyll Sass Converter (version 3.0) for building documentation, while the \project/build.sbt\ adds build-time dependencies on JGit (7.3.0), ASM (9.9), and SnakeYAML (2.4).

(dependencies) · high confidence

Upgrade to Scala.js 1.22.0

The Scala.js backend has been upgraded to version 1.22.0, bringing improvements to the Scala.js compiler and runtime integration. Also in this area: Added Windows ARM64 launcher test job.

project, project/scripts/native-integration · high confidence

Housekeeping

Added placeholder files for compiler source directories

Empty .keep files were added to the compiler/src-bootstrapped and compiler/src-non-bootstrapped directories. These files ensure the directories exist in the repository even when empty, which is a common practice to preserve directory structure in version control systems.

compiler/src-bootstrapped, compiler/src-non-bootstrapped · 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 61 → 64 (+2.3)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.

Lenses

  • Code Health 53 → 53 (-0.4)
  • Architecture 89 → 89 (+0.0)
  • Maturity 66 → 68 (+2.0)
  • Readiness 65 → 69 (+4.2)
  • Security 83 → 81 (-1.8)
  • Performance 72 → 100 (+28.1)

Resolved (48)

  • Duplicated block (12 lines × 2) (library-js/src/scala/collection/immutable/NumericRange.scala)
  • Duplicated block (24 lines × 2) (library-js/src/scala/collection/immutable/NumericRange.scala)
  • Duplicated block (25 lines × 2) (library-js/src/scala/collection/immutable/NumericRange.scala)
  • Duplicated block (26 lines × 2) (compiler/src/scala/quoted/runtime/impl/printers/Extractors.scala)
  • Duplicated block (32 lines × 2) (library/src/scala/util/hashing/MurmurHash3.scala)
  • Duplicated block (3–8 lines × 3) (library/src/scala/jdk/DoubleAccumulator.scala)
  • Duplicated block (5 lines × 2) (compiler/src/scala/quoted/runtime/impl/printers/Extractors.scala)
  • Duplicated block (5 lines × 3) (library/src/scala/jdk/DoubleAccumulator.scala)
  • Duplicated block (8 lines × 2) (compiler/src/dotty/tools/dotc/util/EqHashMap.scala)
  • Duplicated block (8–9 lines × 2) (compiler/src/dotty/tools/debug/JavaEncoding.scala)
  • Hotspot: compiler/src/dotty/tools/backend/jvm/BCodeSkelBuilder.scala (compiler/src/dotty/tools/backend/jvm/BCodeSkelBuilder.scala)
  • Hotspot: compiler/src/dotty/tools/dotc/ast/Desugar.scala (compiler/src/dotty/tools/dotc/ast/Desugar.scala)
  • Hotspot: compiler/src/dotty/tools/dotc/cc/CaptureSet.scala (compiler/src/dotty/tools/dotc/cc/CaptureSet.scala)
  • Hotspot: compiler/src/dotty/tools/dotc/cc/SepCheck.scala (compiler/src/dotty/tools/dotc/cc/SepCheck.scala)
  • Hotspot: compiler/src/dotty/tools/dotc/cc/Synthetics.scala (compiler/src/dotty/tools/dotc/cc/Synthetics.scala)
  • Hotspot: compiler/src/dotty/tools/dotc/core/Comments.scala (compiler/src/dotty/tools/dotc/core/Comments.scala)
  • Hotspot: compiler/src/dotty/tools/dotc/core/TypeApplications.scala (compiler/src/dotty/tools/dotc/core/TypeApplications.scala)
  • Hotspot: compiler/src/dotty/tools/dotc/core/TypeEval.scala (compiler/src/dotty/tools/dotc/core/TypeEval.scala)
  • Hotspot: compiler/src/dotty/tools/dotc/core/tasty/PositionPickler.scala (compiler/src/dotty/tools/dotc/core/tasty/PositionPickler.scala)
  • Hotspot: compiler/src/dotty/tools/dotc/inlines/Inlines.scala (compiler/src/dotty/tools/dotc/inlines/Inlines.scala)
  • …and 28 more

New (215)

  • DesugarSpecializedTraits.generatedVariantStats (cognitive 34) (compiler/src/dotty/tools/dotc/transform/DesugarSpecializedTraits.scala)
  • DesugarSpecializedTraits.generatedVariantStats (cyclomatic 23) (compiler/src/dotty/tools/dotc/transform/DesugarSpecializedTraits.scala)
  • Duplicated block (14 lines × 2) (library/src/scala/util/hashing/MurmurHash3.scala)
  • Duplicated block (9 lines × 2) (library/src/scala/util/hashing/MurmurHash3.scala)
  • Edited copies of one member (3 members, 10+ corresponding lines) (library/src/scala/jdk/DoubleAccumulator.scala)
  • Edited copies of one member (3 members, 11+ corresponding lines) (compiler/src/dotty/tools/backend/jvm/opt/OptimizerKnownBTypes.scala)
  • Edited copies of one member (3 members, 11+ corresponding lines) (library/src/scala/runtime/Tuple2Zipped.scala)
  • Edited copies of one member (3 members, 12+ corresponding lines) (compiler/src/dotty/tools/dotc/core/Substituters.scala)
  • Edited copies of one member (3 members, 12+ corresponding lines) (compiler/src/dotty/tools/dotc/transform/init/Objects.scala)
  • Edited copies of one member (3 members, 12+ corresponding lines) (compiler/src/dotty/tools/dotc/transform/init/Objects.scala)
  • Edited copies of one member (3 members, 18+ corresponding lines) (library/src/scala/runtime/BoxesRunTime.java)
  • Edited copies of one member (3 members, 18+ corresponding lines) (library/src/scala/runtime/BoxesRunTime.java)
  • Edited copies of one member (3 members, 19+ corresponding lines) (library/src/scala/jdk/DoubleAccumulator.scala)
  • Edited copies of one member (3 members, 27+ corresponding lines) (library/src/scala/runtime/BoxesRunTime.java)
  • Edited copies of one member (3 members, 3+ corresponding lines) (library-js/src/scala/reflect/Manifest.scala)
  • Edited copies of one member (3 members, 4+ corresponding lines) (library/src/scala/jdk/DoubleAccumulator.scala)
  • Edited copies of one member (3 members, 4+ corresponding lines) (library/src/scala/runtime/java8/JFunction2$mcVDD$sp.scala)
  • Edited copies of one member (3 members, 4+ corresponding lines) (library/src/scala/runtime/java8/JFunction2$mcVDI$sp.scala)
  • Edited copies of one member (3 members, 4+ corresponding lines) (library/src/scala/runtime/java8/JFunction2$mcVDJ$sp.scala)
  • Edited copies of one member (3 members, 5+ corresponding lines) (compiler/src/dotty/tools/dotc/ast/TreeInfo.scala)
  • …and 195 more

Changes since last survey

  • 115 commits — 93 feature/other, 22 fixes

By area

  • compiler/src — 36 commits
  • .github/workflows — 17 commits
  • (repo) — 12 commits
  • tests/neg-custom-args — 9 commits
  • library/src — 6 commits
  • tests/explicit-nulls — 6 commits
  • project/Build.scala — 4 commits
  • repl/src — 3 commits
  • project/Versions.scala — 2 commits
  • scaladoc-testcases/src — 2 commits
  • (root) — 1 commit
  • compiler/test — 1 commit
  • docs/_docs — 1 commit
  • presentation-compiler/test — 1 commit
  • project/Dependencies.scala — 1 commit
  • project/ScaladocConfigs0.scala — 1 commit
  • project/scripts — 1 commit
  • repl/test — 1 commit
  • sbt-test/java-compat — 1 commit
  • scaladoc/resources — 1 commit

Notable commits

  • fix: CC: fix incorrect greatestClassifier (#27478)
  • fix: Clean up Settings, fix Scaladoc issues this unearths (#27005)
  • fix: Fix #27518: Drop private flags for retainsByName parameters too (#27523)
  • fix: Fix #27521: Detect overlap of exclusive root with read-only path in separation checking (#27524)
  • fix: Fix coverage nightly breakage (#27411)
  • fix: Fix doc comments that render as broken or dead links (#27406)
  • fix: Fix double annotation edge case and Improve tests
  • fix: Fix infinite recursion in avoidance on cyclic type variable instances (#27470)
  • fix: Fix scaladoc with new nullness; drop null annotations on special symbols
  • fix: Fix subsumes test for "GlobalCap subsumes derived capability"
  • fix: Fix subsumes test for GlobalCap subsumes derived capability (#27535)
  • fix: Fix under-approximation of capture sets of intersections
  • fix: Fix under-approximation of capture sets of intersections (#27541)
  • fix: Revert NonFatal narrowing in concurrent and LazyList defended by new tests (#27414)
  • fix: Scaladoc: add regression tests for #27529 (#27598)
  • fix: Scaladoc: fix and adopt the dynamic side menu (124→24 MB compiler javadoc) (#27403)
  • fix: Switch CI JDKs to Zulu for the eMudhra/emSign fix (#27417)
  • fix: Try to fix flaky i21015 pos-deep-subtype (#27441)
  • fix: Two fixes for intersections of capturing types
  • fix: Two fixes for intersections of capturing types (#27532)
  • …and 95 more

Architecture

  • Containers 0 added · 0 removed · contexts 3 added · 0 removed · edges 4 added · 8 removed

Added bounded contexts (3)

  • i14432
  • i24998
  • mirror-product

Added dependency edges (4)

  • analyzer-plugin → repository
  • i24998 → repository
  • repository → i8847
  • scaladoc → repository

Removed dependency edges (was a dependency, now gone) (8)

  • analyzer-plugin → repository (coupling)
  • analyzer-plugin → scaladoc
  • anon-prod-mirrors-3.1 → repository
  • hierarchical-mirrors-3.0 → repository
  • mirror-sum → repository
  • repository → analyzer-plugin
  • repository → scaladoc
  • scaladoc → repository (coupling)

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

Survey your own repository

scala/scala3 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 14 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 bcea7d112dca5f93c700d4335117b5cd318fed3d — the exact code this score is about.
  • Scored under rubric-2026.11.4 — 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.65+preprod-36d4cd83012f.