Skip to content
CAI
Software that uses CAICheck a score

scala/scala

61.1

Adequate · 11 November 2026

257.7k

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 Scala wrappers for Java reference classes

Added new classes in the \scala.ref\ package (\WeakReference\, \SoftReference\, \PhantomReference\, \ReferenceQueue\, \Reference\, and \ReferenceWrapper\) that wrap Java's \java.lang.ref\ equivalents. These wrappers provide a Scala-friendly API by returning \Option\[T\]\ values instead of \null\ and include companion objects with extractors (\unapply\) to enable pattern matching on reference values.

src/library/scala/ref · high confidence

Add client-side scripts for specification PDF generation and rendering

This change introduces the JavaScript assets required to generate and render the specification PDF. It adds a bundled highlight.js library (with a Scala language definition) and a jQuery Table of Contents plugin (v0.3.2) to handle syntax highlighting and navigation, respectively. The main script configures KaTeX to use the acute accent (´) as the inline math delimiter and disables language auto-detection in highlight.js to prevent EBNF code blocks from being incorrectly identified as Scala. These files also include the corresponding license headers for the third-party libraries.

spec/public/scripts · high confidence

Add internal Profiler for bytecode instrumentation statistics

The partest framework now includes an internal Profiler class used during bytecode instrumentation to track method invocation counts. This component allows the testing infrastructure to collect and expose statistics on which methods are called and how often, supporting deeper analysis of instrumented test runs.

src/partest/scala/tools/partest/instrumented · high confidence

Add partest configuration loader

The partest test runner now includes a \Properties\ utility object that loads configuration from the \scala-partest.properties\ file within the JAR. This object extends \scala.util.PropertiesTrait\ to provide access to partest-specific settings, such as detecting the Avian JVM environment.

src/partest/scala/tools/partest/utils · high confidence

Added Java agent for bytecode profiling in partest

The partest-javaagent module now includes a Java agent that instruments bytecode to profile method execution. This agent, defined by ProfilingAgent and ASMTransformer, uses the ASM library to insert calls to a Profiler class for non-abstract methods in the scala package, empty package, and instrumented package, enabling runtime performance analysis of test cases.

src/partest-javaagent · high confidence

Added Octicons font library and assets

Added the Octicons font library to the public assets, including the CSS stylesheet defining icon classes (such as .octicon and .mega-octicon), the font files (EOT, WOFF, TTF, SVG), and the associated license file.

spec/public/octicons · high confidence

Added Scala Tools and Utilities documentation page

A new documentation page has been added to the manual resources, providing an overview of the core Scala SDK tools. The page lists and links to reference documentation for the fast Scala compiler (fsc), the Scala interpreter (scala), the compiler (scalac), the API document generator (scaladoc), and the class file decoder (scalap). It also includes general information sections on setting the classpath and how classes are found, with platform-specific links for Solaris, Linux, and Windows.

src/manual/scala/tools/docutil/resources · high confidence

Added auxiliary documentation stubs for core Scala types

New stub source files have been added to the \src/library-aux\ directory to support bootstrapping and documentation generation for fundamental Scala types. This includes \Any.scala\, \AnyRef.scala\, \Nothing.scala\, \Null.scala\, and \Singleton.scala\, which define the root classes, traits, and bottom types of the Scala hierarchy along with their associated Scaladoc comments.

src/library-aux · high confidence

Added internal async macro state machine implementation

The testkit now includes the internal implementation for its \async\ macro, introducing \Async.scala\ and \AsyncStateMachine.scala\. This adds the \AsyncAsMacroStateMachine\ abstract class and the \AsyncStateMachine\ trait, which provide the underlying finite-state machine logic required to translate \async\/\await\ blocks into \Future\-based execution. This change supports the testkit's asynchronous testing capabilities by defining the structural interface and execution state management used by the macro.

src/testkit/scala/tools/testkit/async · high confidence

Added specialized Java 8 Function interfaces for primitive types

The library now includes a comprehensive set of new \JFunction0\, \JFunction1\, and \JFunction2\ traits in the \scala.runtime.java8\ package. These interfaces provide specialized versions of the standard Java 8 \Function\ types that accept and return primitive types (such as \int\, \double\, \long\, \float\, \boolean\, \byte\, \char\, \short\, and \Unit\). This allows for more efficient interoperability with Java 8 code by avoiding unnecessary boxing and unboxing of primitive values.

src/library/scala/runtime/java8 · high confidence

Compiler plugins can now customize JAR output and manifests

The compiler plugin API has been extended to allow plugins to contribute resources to generated output files and modify JAR manifests. A new \OutputFileWriter\ trait and corresponding \writeAdditionalOutputs\ callback on \Plugin\ enable plugins to package resources or services directly into JARs during compilation, reducing the need for post-build steps. Additionally, the \augmentManifest\ method allows plugins to customize the manifest of the output JAR, which is particularly useful for multi-output compilations where the manifest must be the first entry.

src/compiler/scala/tools/nsc/plugins · high confidence

Enhanced compiler profiling with per-phase metrics and external tool hooks

The compiler's profiling subsystem (enabled via -Yprofile-enabled) now provides significantly more detailed metrics per compilation phase, including wall clock time, idle time, CPU time, user time, allocated bytes, retained heap, and GC time. It also introduces an external tool hook (-Yprofile-external-tool) to allow profilers like YourKit or JProfiler to instrument specific phases, and adds support for detailed Chrome trace output (-Yprofile-trace). These changes improve the ability to diagnose performance bottlenecks in multi-threaded compilation.

src/compiler/scala/tools/nsc/profile · high confidence

Initial release of the Scala Language Specification

The \spec/\ directory now contains the complete, chapter-based Scala Language Specification (SLS) in Markdown format. This includes the full text for lexical syntax, identifiers and scopes, types, basic declarations and definitions, classes and objects, expressions, implicits, pattern matching, and top-level definitions, providing the authoritative reference for the language's grammar and semantics.

spec · high confidence

Internal macro implementation linking annotation added

A new internal annotation, \scala.reflect.macros.internal.macroImpl\, has been added to the Scala library. This annotation is used to link macro definitions with their implementations, ensuring that the connection between a macro definition and its implementation is preserved across compilation runs. It is defined as a private annotation within the \scala\ package to prevent application developers and Scaladoc from exposing it, while still allowing it to be pickled and used by the compiler.

src/library/scala/reflect/macros · high confidence

Introduce GenBCode as the new bytecode emitter

The compiler backend now includes a new bytecode generation component, GenBCode, which replaces the legacy GenASM implementation. This change introduces a new set of files in the \src/compiler/scala/tools/nsc/backend/jvm\ directory, including \AsmUtils\ for debugging, \BCodeBodyBuilder\ for constructing method bodies, \BCodeIdiomatic\ for high-level ASM API interactions, and \ClassfileWriters\ for handling output. GenBCode provides a modernized pipeline for generating JVM class files, supporting features like invokedynamic for lambdas and improved inlining, while the old GenASM code is being removed.

src/compiler/scala/tools/nsc/backend/jvm · high confidence

Introduce SBTRunner for SBT integration

Added SBTRunner, a new component that enables running partest suites within the SBT test interface. This implementation integrates with SBT's testing API to propagate test events, including status, duration, and failure transcripts, while supporting configuration overrides for colors, Java options, and Scala compiler arguments.

src/partest/scala/tools/partest/sbt · high confidence

Introduce TastyTest as a dedicated Scala 2/3 interoperability test harness

A new \tastytest\ tool is added to the compiler distribution, providing a unified framework for testing Scala 2/3 interoperability via TASTy. It introduces a command-line interface with subcommands for invoking \dotc\ (Scala 3), \scalac\ (Scala 2), \javac\, \scaladoc\, and a TASTy decompiler (\dotcd\). The harness includes built-in test suites that simulate real-world scenarios, such as a Scala 2 application depending on a Scala 3 library (positive and negative tests), pipeline-compatible compilation using TASTy-only classpaths, and full-circle dependency checks. It also supports running compiled test classes and capturing their output for verification.

src/tastytest · high confidence

Introduce async DSL support for CompletableFuture, Option, and Output in partest

The partest framework now includes a new asynchronous testing DSL located in \src/partest/scala/tools/partest/async\. This addition introduces three specific async contexts: \CompletableFutureAwait\ for handling \java.util.concurrent.CompletableFuture\ results, \OptionAwait\ for \Option\-based async flows, and \OutputAwait\ for capturing both a result value and a map of written outputs. These components provide macro-based entry points (\async\, \optionally\, \writing\) that allow partest tests to await asynchronous operations in a structured, state-machine-driven manner.

src/partest/scala/tools/partest/async · high confidence

Introduce specialized runtime support for lambdas and lazy vals

The standard library now includes new runtime classes to support lambda deserialization and specialized lazy value holders. \LambdaDeserialize\ and \LambdaDeserializer\ provide the infrastructure for deserializing lambda expressions at runtime, while \LazyRef\ and its specialized variants (e.g., \LazyInt\, \LazyDouble\) serve as holders for method-local lazy vals, enabling more efficient evaluation and storage of lazy values without unnecessary boxing.

src/library/scala/runtime · high confidence

Introduces new internal reflection traits and refactors type system components

This change adds several new internal traits to the reflection subsystem, including \AnnotationCheckers\ for plugin-driven annotation validation, \CapturedVariables\ for handling captured variable boxing, and \Chars\ for character classification. It also introduces new value classes for \Depth\ and \FlagSet\ (using \Long\ instead of \Int\), and adds \BaseTypeSeqs\ to manage base type sequences more efficiently. These modifications support the broader internal refactoring of the Scala compiler's type system and reflection APIs.

src/reflect/scala/reflect/internal · high confidence

Introduces the 'nest' test runner framework for partest

The partest tool now includes a new internal test runner framework located in the \scala.tools.partest.nest\ package. This framework provides a structured, DSL-based approach to command-line argument parsing (via \CommandLine\, \Opt\, and \Spec\ traits), manages test execution and reporting (via \AbstractRunner\ and \DirectCompiler\), and handles file system operations and environment capture (via \FileManager\, \PathSettings\, and \StreamCapture\). It also includes utilities for generating shell completions and runner scripts (\Meta\, \Interpolation\) and a \DelegatingSecurityManager\ to support JVM security checks while suppressing JDK 17 deprecation warnings.

src/partest/scala/tools/partest/nest · high confidence

Introduction of ClassTag and Manifest APIs in scala.reflect

The \src/library/scala/reflect\ area now provides the core runtime reflection types \ClassTag\ and \Manifest\ (along with supporting types like \OptManifest\, \NoManifest\, and \ManifestFactory\). \ClassTag\ allows users to create arrays of unknown element types at runtime and perform checked pattern matches, while \Manifest\ extends this capability to capture type arguments for generic types. These APIs replace the older \ClassManifest\ system, which is now deprecated in favor of these new, more robust reflection primitives.

src/library/scala/reflect · high confidence

Introduction of Scala signature pickling infrastructure

The reflection subsystem now includes a new internal mechanism for serializing and deserializing Scala symbol tables and type information into classfile annotations (pickles). This change introduces the core components for this feature: \PickleFormat\ defines the binary schema and version constants (major 5, minor 2); \PickleBuffer\ provides the low-level byte array handling for reading and writing the encoded data; \ByteCodecs\ implements the specific encoding rules (such as modified UTF-8 and 8-to-7 bit packing) required to store this data safely in classfiles; \Translations\ maps internal Scala types, symbols, and trees to the specific tags used in the pickle format; and \UnPickler\ reconstructs the symbol table from these byte arrays. This infrastructure enables the compiler to embed reflection metadata directly into compiled classfiles.

src/reflect/scala/reflect/internal/pickling · high confidence

Introduction of blackbox macro context API

The \scala.reflect.macros.blackbox.Context\ trait is now available, providing a specific API for macro writers to create blackbox macros. This context enforces that macro expansions are upcast to their declared return types, ensuring type safety and faithfulness to the macro's signature, which distinguishes it from whitebox macros that allow more flexible but less supported expansion behaviors.

src/reflect/scala/reflect/macros/blackbox · high confidence

Introduction of dedicated Java lexer and parser components

The compiler now includes a dedicated Java token definition file (JavaTokens.scala), a Java scanner implementation (JavaScanners.scala), and a Java parser implementation (JavaParsers.scala) within the \src/compiler/scala/tools/nsc/javac\ directory. These new files provide the foundational infrastructure for the compiler to lex, scan, and parse Java source code, separating Java-specific tokenization and parsing logic from the general Scala parser.

src/compiler/scala/tools/nsc/javac · high confidence

Introduction of scala.concurrent.duration API and DSL

The \scala.concurrent.duration\ package is introduced, providing a new type-safe API for handling time durations. This includes the \Duration\, \FiniteDuration\, and \Infinite\ types, along with special values like \Zero\, \Inf\, \MinusInf\, and \Undefined\. A key addition is the implicit conversion DSL, allowing developers to write expressive code such as \2 seconds\, \5 minutes\, or \3 seconds fromNow\ by importing \scala.concurrent.duration.\_\. The implementation supports parsing durations from strings, converting between time units, and handles edge cases like deserialization of singleton infinite values.

src/library/scala/concurrent/duration · high confidence

Introduction of scala.util.matching.Regex for pattern matching and text replacement

The \scala.util.matching.Regex\ class is now available, providing a wrapper around Java's \java.util.regex\ package to enable regular expression matching, extraction of capturing groups, and text replacement. Users can create regex instances via the implicit \r\ method on strings (including raw strings) and use them as extractors in pattern matches, find matches using methods like \findFirstIn\ and \findAllIn\, and replace matched text using \replaceAllIn\.

src/library/scala/util/matching · high confidence

Introduction of the Scala Reflection API

This change introduces the \scala.reflect.api\ package, establishing the public interface for Scala's reflection capabilities. It defines core abstractions including \Universe\, \Mirror\, and \Expr\, alongside specific APIs for handling annotations, constants, flags, and type tags. This structure separates the reflection API from its internal implementation, providing a stable contract for runtime and compile-time reflection tools.

src/reflect/scala/reflect/api · high confidence

Introduction of the scala.concurrent API

This change introduces the core \scala.concurrent\ package, providing the foundational types for asynchronous programming in Scala. It adds the \Future\ and \Promise\ traits for representing asynchronous computations and their mutable counterparts, along with the \ExecutionContext\ for managing thread pools and task execution. The API also includes \Await\ and \Awaitable\ for blocking on results, \BatchingExecutor\ for optimizing nested task execution, and \BlockContext\ for handling blocking signals. Additionally, it introduces legacy synchronization primitives like \SyncVar\, \SyncChannel\, and \Channel\, which are marked as deprecated in favor of standard Java concurrency utilities.

src/library/scala/concurrent · high confidence

Introduction of the scala.sys.process DSL for external command execution

The \scala.sys.process\ package now provides a DSL for running and chaining external processes, mimicking Unix shell capabilities. Users can create \ProcessBuilder\ instances from strings or sequences, combine them using operators like \\#\|\ (pipe), \\#&&\ (conditional AND), and \\#\|\|\ (conditional OR), and execute them with methods such as \!\ (exit value), \!!\ (output string), and \lazyLines\ (lazy output stream). The package includes \ProcessLogger\ for capturing output, \ProcessIO\ for fine-grained I/O control, and \BasicIO\ for common I/O configurations.

src/library/scala/sys/process · high confidence

Introduction of the scala.util.hashing package

The standard library now includes a new \scala.util.hashing\ package, providing a structured API for hashing operations. This introduces the \Hashing\[T\]\ trait to define custom hashing strategies, a \ByteswapHashing\ implementation based on Phil Bagwell's fast multiplicative hash, and the \MurmurHash3\ algorithm for computing hash codes for collections, tuples, strings, and case classes. Users can now leverage these utilities for more control over hash generation or to optimize performance in collection-based data structures.

src/library/scala/util/hashing · high confidence

Manual pages and HTML documentation are now generated via sbt

The manual documentation build process has been migrated to use sbt, introducing new tools in \src/manual/scala/tools/docutil\ to generate both man pages and HTML output. This change adds \EmitHtml\ and \EmitManPage\ modules to handle the rendering of documentation sections, lists, and formatting, along with a \ManMaker\ class to orchestrate the generation of these files into specified output directories. A corresponding CSS stylesheet (\style.css\) is included to style the generated HTML pages, ensuring consistent presentation of the manual content.

src/manual/scala/tools/docutil · high confidence

New CI and release automation scripts for bootstrapping, testing, and publishing

This change introduces a suite of new shell scripts to automate the Scala build and release pipeline. The \bootstrap\_fun\ and \common\ scripts handle the bootstrapping process (building a 'starr' and 'locker' version of Scala), managing Ivy caches, and configuring sbt repositories for both Jenkins and Travis CI environments. A new \stability-test.sh\ script verifies binary compatibility by comparing class files between a 'quick' build and a 'strap' build. Additionally, \generate-spec-pdf.sh\ and \generate-spec-pdf.bat\ automate the creation of specification PDFs from HTML sources, while \travis-publish-spec.sh\ securely uploads these specs to an external server. These scripts collectively replace or supplement previous build logic, streamlining the integration, testing, and distribution workflows.

scripts · high confidence

New CI validation scripts for publishing and testing Scala core

Added two new CI validation scripts, \scripts/jobs/validate/publish-core\ and \scripts/jobs/validate/test\, to automate the publishing of Scala core artifacts to Maven and the execution of the full test suite. The \publish-core\ script handles version resolution, checks for artifact availability, and publishes the core libraries (scala-library, scala-reflect, scala-compiler) using sbt, while the \test\ script orchestrates the build and runs JUnit, ScalaCheck, partest, OSGi, MiMa, and scaladoc tests against the validated version.

scripts/jobs · high confidence

New JVM backend analysis components for nullness and aliasing

The compiler's JVM backend now includes a suite of new analysis tools in the \analysis\ package to improve bytecode optimization. This introduces \AliasingAnalyzer\ to track value aliases, \NullnessAnalyzer\ to determine null states, \ProdConsAnalyzer\ for producer/consumer data flow, and \TypeFlowAnalyzer\ for type flow. These components enable more precise optimizations, such as branch-sensitive nullness checks and better dead code elimination, by providing detailed insights into local variables and stack values during code generation. Also in this area: 3 commits (0 fixes) modifying src/compiler.

src/compiler/scala/tools/nsc/backend/jvm/analysis · medium confidence · unverified

New Scaladoc doclet API for custom generators

The Scaladoc tooling now exposes a new \doclet\ package containing the \Generator\ abstract class and the \Universer\ trait, enabling users to create custom documentation generators via the \-doc-generator\ command-line option. The \Generator\ class provides the entry point for documentation output and includes a validation mechanism (\checks\) to ensure prerequisites are met before generation begins, while the \Universer\ trait allows these custom generators to access the underlying program model (the \Universe\) for richer documentation content.

src/scaladoc/scala/tools/nsc/doc/doclet · high confidence

New Stepper implementations for standard collection types

The standard library now includes specialized Stepper implementations for arrays, vectors, bit sets, ranges, strings, iterators, binary trees, and hash maps/sets (via Champ and Table structures). These new internal classes enable efficient, splittable traversal of these collections, which is a prerequisite for high-performance parallel streams and other bulk operations.

src/library/scala/collection/convert/impl · high confidence

New compiler diagnostics and resource management utilities

The compiler now includes a \CloseableRegistry\ to manage resource cleanup when the \Global\ compiler instance is closed, and a \ClassPathMemoryConsumptionTester\ tool to benchmark memory usage of different classpath representations. Additionally, \CompilationUnits\ now supports dependency tracking via the \-Ytrack-dependencies\ setting (disabled by default) to improve incremental build compatibility, and \GenericRunnerSettings\ introduces \-howtorun\ and \-save\ options to control script execution modes.

src/compiler/scala/tools/nsc · high confidence

New control-flow abstractions: Breaks, TailCalls, and ControlThrowable

The \scala.util.control\ package now includes new APIs for structured control flow. \Breaks\ provides \break\ and \breakable\ methods to allow exiting loops or blocks early, using a lightweight \ControlThrowable\ that is excluded from \NonFatal\ matches to prevent accidental interception. \TailCalls\ introduces trampolining via \tailcall\ and \done\ to enable stack-safe recursive computations without growing the call stack. \ControlThrowable\ is a new base class for flow-control exceptions with stack traces and suppression disabled for performance and safety.

src/library/scala/util/control · high confidence

New developer utility scripts and removal of legacy binary-repo library

The tools directory now includes several new shell scripts to aid development and maintenance: \scaladoc-diff\ and \scaladoc-compare\ for tracking API documentation changes, \verify-jar-cache\ for detecting and removing corrupt cached JARs, \cleanup-commit\ for pre-commit whitespace normalization, \compare-java-sigs\ for comparing Java signatures, and helpers like \abspath\, \class-dump\, \cpof\, \jar-dump\, \pathResolver\, and \rm-orphan-checkfiles\. Additionally, the legacy \binary-repo-lib.sh\ script and its associated \push.jar.desired.sha1\ file have been removed.

tools · high confidence

New explicit Java/Scala collection conversion API

The \scala.jdk.CollectionConverters\ object is now available, providing explicit \asJava\ and \asScala\ extension methods for converting between Scala and Java collections (such as \Iterator\, \List\, \Set\, \Map\, and \Stream\). This new API replaces the legacy \collection.JavaConverters\ and \collection.JavaConversions\ (which are now deprecated), encouraging explicit conversions to avoid the ambiguity and potential type-safety issues of the previous implicit conversions.

src/library/scala/collection/convert · high confidence

New internal utility classes for reflection and compiler performance

The \scala.reflect.internal.util\ package now includes several new internal classes to support the reflection library and compiler internals. \AbstractFileClassLoader\ provides a class loader that loads files from an \AbstractFile\, enabling resource loading from virtual file systems. \AlmostFinalValue\ introduces a JVM-level optimization mechanism using \MutableCallSite\ to allow the JIT compiler to speculate on boolean flags, improving performance for statistics and debug toggles. \ChromeTrace\ adds support for writing Chrome DevTools Protocol trace events, allowing developers to profile compiler performance in Chrome's tracing tools. \CodeAction\ and \TextEdit\ provide structured data types for communicating code edit suggestions to tooling, aligning with the Language Server Protocol. \Collections\ adds optimized, allocation-aware collection operations like \map2Conserve\ and \mapList\ to reduce garbage collection pressure. \FileUtils\ introduces an asynchronous buffered writer for efficient file I/O. \FreshNameCreator\ offers a thread-safe mechanism for generating unique identifiers. \HashSet\ provides a custom, low-overhead hash set implementation. \JavaClearable\ wraps Java collections and maps with weak references to allow safe clearing. \Origins\ is a debugging tool for tracking call origins. \OwnerOnlyChmod\ handles secure file permission setting. \Position\ consolidates position handling logic. \ReusableInstance\ provides a reentrant caching mechanism for instances. \ScalaClassLoader\ enhances class loading capabilities with context management and class creation utilities.

src/reflect/scala/reflect/internal/util · high confidence

New javaapi conversion utilities for Java interop

Added explicit conversion objects in the scala.jdk.javaapi package (CollectionConverters, DurationConverters, FunctionConverters, FutureConverters, OptionConverters, and StreamConverters) to facilitate interoperability between Scala and Java types. These utilities provide static methods intended for use in Java code, such as converting Scala collections to Java lists, Scala Futures to Java CompletionStages, and Scala Options to Java Optionals, while recommending the extension methods in the scala.jdk package for Scala code.

src/library/scala/jdk/javaapi · high confidence

New macro utility helpers for type transformation and debug logging

The compiler now includes new utility traits in \scala.reflect.macros.util\ to assist with macro implementation details. \Helpers\ provides methods to transform macro implementation parameters by filtering or modifying WeakTypeTag evidence, and offers utilities to adjust type metalevels (converting between \c.Expr\[T\]\ and \T\) which simplifies signature analysis and argument handling for macro authors. Additionally, \Traces\ introduces lightweight debug logging capabilities controlled by the \YmacrodebugLite\ and \YmacrodebugVerbose\ compiler flags, allowing users to enable verbose macro debugging output when needed.

src/compiler/scala/reflect/macros/util · high confidence

New meta-annotation targets for precise annotation placement

The \scala.annotation.meta\ package now includes new meta-annotations (\companionClass\, \companionMethod\, \companionObject\, \beanGetter\, \beanSetter\) that allow developers to control exactly where annotations on implicit classes and bean properties are applied. Previously, annotations on implicit classes were only applied to the class itself; these new targets enable them to be directed to the generated conversion method or companion objects. Additionally, \defaultArg\ and \superArg\/\superFwdArg\ meta-annotations were added to support encoding default arguments and superclass arguments in annotation definitions, enabling more complex annotation structures to be preserved in the compiled class files.

src/library/scala/annotation/meta · high confidence

New parser infrastructure components for brace healing and token handling

The parser module introduces several new internal classes to support improved syntax error recovery and token management. BracePair and BracePatch provide the data structures and logic for detecting and fixing mismatched braces (brace healing), while Patch serves as the base for these modifications. CommonTokens and Tokens define the shared and Scala-specific token constants used by the scanner, and TreeBuilder contains the methods for constructing untyped AST nodes. These components are wired together by SyntaxAnalyzer, which orchestrates the parsing phase.

src/compiler/scala/tools/nsc/ast/parser · high confidence

New partest infrastructure for bytecode, icode, and compiler-internal testing

The partest framework now includes a suite of new test base classes that enable more granular and robust testing of the Scala compiler. Users can now write tests that inspect generated bytecode using the ASM library (BytecodeTest), compare intermediate icode representations with and without optimization (IcodeTest, IcodeComparison), and directly test compiler internals and settings without launching a full JVM process (DirectTest, CompilerTest). Additionally, new utilities support REPL session testing (ReplTest, SessionTest), JUnit integration (JUnitTest), and Scaladoc model verification (ScaladocModelTest), providing a more structured approach to validating compiler behavior and documentation generation.

src/partest/scala/tools/partest · high confidence

New sbt build infrastructure and build-time code generation

The project introduces a comprehensive sbt-based build system, replacing previous build mechanisms. This includes new build plugins for OSGi packaging (Osgi.scala), binary compatibility checking with MiMa (MimaFilters.scala), license file inclusion (License.scala), and Automatic-Module-Name configuration (AutomaticModuleName.scala). It also adds build-time code generation for AnyVal types (GenerateAnyVals.scala), Java function converters (GenerateFunctionConverters.scala), and compiler option documentation (GenerateDocsData.scala), alongside utilities for JMH benchmark analysis (JitWatch.scala) and partest test execution (PartestTestListener.scala, PartestUtil.scala).

project · high confidence

New scala.jdk package with Java interoperability converters and specialized Accumulators

The \scala.jdk\ package introduces a new set of extension objects for converting between Scala and Java types, including \CollectionConverters\ for collections, \FunctionConverters\ for Java function interfaces, \FutureConverters\ for \Future\/\CompletionStage\, \DurationConverters\ for time durations, and \StreamConverters\ for Java streams. Additionally, it adds \Accumulator\ classes (\IntAccumulator\, \LongAccumulator\, \DoubleAccumulator\, \AnyAccumulator\) which are mutable sequences optimized for efficient parallel collection and specialized for primitive types to avoid boxing.

src/library/scala/jdk · high confidence

New symbol browsing and tracking capabilities in the compiler

The compiler now includes new internal components in the \symtab\ package to support IDE-like browsing and symbol tracking. \BrowsingLoaders\ allows the compiler to parse and enter top-level symbols from source files without full completion, enabling faster feedback for code navigation and completion. \SymbolTrackers\ provides a mechanism to snapshot and diff symbol states (including additions, removals, owner changes, and flag changes) across compilation phases, which aids in debugging and understanding symbol resolution behavior.

src/compiler/scala/tools/nsc/symtab · high confidence

New type-class infrastructure for collection extension methods

The \scala.collection.generic\ package now includes new type classes (\IsIterable\, \IsIterableOnce\, \IsSeq\, \IsMap\) and supporting utilities (\BitOperations\, \CommonErrors\) that enable generic extension methods to work uniformly across standard collections and convertible types like \String\ and \Array\. This infrastructure allows library authors to write methods that apply to any type that can be viewed as an iterable or sequence, while also introducing private helper objects to optimize bit operations and error message generation. Additionally, legacy type aliases such as \IsTraversableLike\ and \CanBuildFrom\ are now deprecated in favor of these new abstractions.

src/library/scala/collection/generic · high confidence

New unchecked annotations for override, stability, and variance

Three new annotations have been added to the \scala.annotation.unchecked\ package to allow developers to bypass specific compiler checks. \@uncheckedOverride\ marks a definition as an override without enforcing that it actually overrides a member in a superclass. \@uncheckedStable\ allows values with volatile types to be treated as stable, applicable to both fields and getters. \@uncheckedVariance\ suppresses variance checking for specific type arguments.

src/library/scala/annotation/unchecked · high confidence

New utility types and methods in scala.util

This change introduces several new capabilities to the standard library. It adds \scala.util.Try\ for handling computations that may fail with an exception, and \scala.util.Either\ as a right-biased alternative to \Option\ for representing success or failure with associated data. It also introduces \scala.util.Using\ for automatic resource management, \scala.util.ChainingOps\ (accessible via \scala.util.chaining.\_\) to add \tap\ and \pipe\ methods for fluent chaining, and \scala.util.DynamicVariable\ (renamed from \Fluid\) for thread-local dynamic scoping. Additionally, \scala.util.Random\ is moved to this package and \scala.util.Sorting\ is added for array sorting operations.

src/library/scala/util · high confidence

Repository initialization and contributor documentation

The repository has been initialized with essential contributor documentation, including a README, CONTRIBUTING guide, Code of Conduct, and an AI Agents guide. A .mailmap file is added to normalize contributor email addresses, and .gitattributes is configured to enforce LF line endings for source files on Windows. The build configuration is pinned to sbt 1.x via .scala-steward.conf, and versions.properties defines the bootstrapping compiler (STARR) as 2.13.19-M1, along with dependencies for scala-asm (9.11.1) and JLine (3.30.16). Legacy binary library scripts have been removed.

(repo-wide) · high confidence

Resurrected and reorganized the nsc.io package with new Jar and SourceReader implementations

The \src/compiler/scala/tools/nsc/io\ package has been reorganized and expanded. It now includes a new \Jar\ class and \JarWriter\ for creating and reading JAR files (including manifest handling and classpath parsing), and a new \SourceReader\ class that uses NIO channels and charset decoders to read source files efficiently while honoring interrupts. The package object also re-exports core types from \scala.reflect.io\ (such as \AbstractFile\, \File\, \Path\, and \ZipArchive\) and provides an implicit conversion to enrich JAR manifests.

src/compiler/scala/tools/nsc/io · high confidence

Scaladoc now supports entity and member search with package navigation

The Scaladoc generator now includes a client-side search feature that allows users to find classes, traits, methods, values, and type members by name. This change introduces a new search interface in the HTML output, powered by a generated JavaScript index (\IndexScript.scala\) that maps package structures and member details. Additionally, the documentation pages now display a hierarchical package list in the sidebar, allowing users to navigate subpackages directly from the main content pane.

src/scaladoc/scala/tools/nsc/doc/html/page · high confidence

Scaladoc supports explicit short descriptions via @shortDescription

The Scaladoc comment model now supports an explicit \@shortDescription\ annotation. When provided, this annotation defines the short synopsis displayed in entity views and search results, overriding the previous behavior of automatically extracting the first sentence of the main comment body. This allows documentation authors to control the concise summary shown to users independently of the full documentation text.

src/scaladoc/scala/tools/nsc/doc/base · high confidence

Architecture

Quasiquotes implementation moved to scala.reflect

The quasiquotes implementation has been relocated from the compiler's internal packages to the public \scala.reflect.quasiquotes\ package. This change introduces new files (\Holes.scala\, \Parsers.scala\, \Placeholders.scala\, \Quasiquotes.scala\, \Reifiers.scala\) that define the core logic for parsing, hole management, and reification of quasiquotes, making this functionality part of the standard reflection API rather than an internal compiler detail.

src/compiler/scala/reflect/quasiquotes · high confidence

REPL frontend refactored into modular shell components

The REPL frontend has been split into distinct, modular components within the shell package, introducing new interfaces and implementations for core functionalities. This includes a new \History\ trait and \NoHistory\ object for managing command history, an \IBindings\ class to handle variable bindings via the javax.script API, and an \InteractiveReader\ trait to abstract input handling. The main \ILoop\ class now orchestrates the shell using these components, while \LoopCommands\ provides a unified framework for defining and executing REPL commands. Additional new files include \JavacTool\ and \JavapClass\/\Javap\ for Java compilation and bytecode inspection support, \Pasted\ for handling transcript pasting, \ReplCompletion\ for code completion logic, \Reporter\ for structured output and error reporting, and \Scripted\ for javax.script engine integration. This refactoring decouples the shell UI from the compiler internals, relying on the \Repl\/\IMain\ interface for evaluation.

src/repl-frontend/scala/tools/nsc/interpreter/shell · high confidence

Refactored backend platform abstraction and primitive operation definitions

The compiler's backend structure has been reorganized to improve modularity and clarity. A new \Platform\ trait has been introduced to encapsulate platform-specific logic, including classpath management, compilation phase definitions, and symbol handling, with a concrete \JavaPlatform\ implementation provided for JVM targets. Additionally, the \ScalaPrimitives\ file now explicitly defines and maps all supported primitive operations (such as arithmetic, bitwise, comparison, and array operations) to integer codes, providing a centralized demultiplexing mechanism for code generation.

src/compiler/scala/tools/nsc/backend · high confidence

Refactored compiler settings into immutable and mutable abstractions

The compiler's command-line option handling has been restructured to separate the settings interface from their mutable implementation. A new \AbsSettings\ trait defines the immutable API for querying, serializing, and validating settings (such as \visibleSettings\, \userSetSettings\, and \recreateArgs\), while \MutableSettings\ implements this trait to handle the actual parsing and state changes. This change introduces a \PathFactory\ abstraction to decouple path resolution from the settings logic and reorganizes standard, advanced, and warning settings into distinct traits (\StandardScalaSettings\, \ScalaSettings\, \Warnings\) that are mixed into the mutable settings class. For users, this ensures that settings dependencies are strictly checked and that the command-line argument parsing logic is more robust and modular, though the visible set of compiler flags remains largely the same.

src/compiler/scala/tools/nsc/settings · high confidence

Refactored macro context into modular traits

The macro context implementation in \src/compiler/scala/reflect/macros/contexts\ has been restructured from a single monolithic class into a set of composable traits (such as \Aliases\, \Enclosures\, \Evals\, \FrontEnds\, \Internals\, \Names\, \Parsers\, \Reifiers\, \Traces\, and \Typers\) mixed into a new \Context\ class. This change improves the organization and maintainability of the macro runtime by separating concerns like type checking, evaluation, and name generation into distinct modules, while preserving the existing public API surface for macro authors.

src/compiler/scala/reflect/macros/contexts · high confidence

Refactored reification engine into modular phase traits

The reification logic in \src/compiler/scala/reflect/reify/phases\ has been restructured from a monolithic implementation into distinct, composable traits: \Calculate\ (tracking local symbols and metalevels), \Metalevels\ (handling cross-stage bindings and splice validation), \Reify\ (core value reification and stack management), and \Reshape\ (undoing typer changes and normalizing ASTs for reification). This change improves the maintainability and clarity of the macro expansion process by separating concerns such as symbol tracking, metalevel analysis, and AST transformation into dedicated phases.

src/compiler/scala/reflect/reify/phases · high confidence

Reorganization of reification utilities into dedicated modules

The internal implementation of the Scala reifier has been restructured by extracting shared logic from the main reifier into a new \scala.reflect.reify.utils\ package. This change introduces four new components: \Extractors.scala\ for pattern matching reified trees and types, \SymbolTables.scala\ for managing symbol bindings and aliases during reification, \NodePrinters.scala\ for generating human-readable debug output of reified code, and \StdAttachments.scala\ for handling reification-specific metadata. These utilities are consolidated under a new \Utils\ trait, improving code modularity and maintainability without altering the external reification API.

src/compiler/scala/reflect/reify/utils · high confidence

Scaladoc HTML generation engine refactored into new package structure

The Scaladoc HTML generation logic has been reorganized into the \scala.tools.nsc.doc.html\ package, introducing new core components: \Doclet\ (the entry point for documentation generation), \HtmlFactory\ (which handles resource copying, including jQuery with Subresource Integrity verification, and template writing), \HtmlPage\ (managing HTML output, inline formatting, and table rendering), \Page\ (handling file paths, relative links, and entity kind strings), and \SyntaxHigh\ (providing syntax highlighting for code blocks). This change moves the sources into a separate directory and updates the copyright to Lightbend, Inc. dba Akka.

src/scaladoc/scala/tools/nsc/doc/html · high confidence

Scaladoc diagram model and generation logic moved to new package

The core classes and traits for generating Scaladoc diagrams (inheritance and content diagrams) have been relocated from the \scala.tools.nsc.doc.model\ package into a new \scala.tools.nsc.doc.model.diagram\ package. This change introduces \Diagram.scala\ with the base \Diagram\, \Node\, and specific diagram types (\ContentDiagram\, \InheritanceDiagram\), alongside \DiagramDirectiveParser.scala\ and \DiagramFactory.scala\ which handle parsing \@{inherit,content}Diagram\ annotations and constructing the diagram structures. This reorganization isolates the diagramming logic within the scaladoc module.

src/scaladoc/scala/tools/nsc/doc/model/diagram · high confidence

Scaladoc model layer refactored into modular traits

The Scaladoc model implementation in \src/scaladoc/scala/tools/nsc/doc/model\ has been restructured from a monolithic \ModelFactory\ into a set of focused, composable traits. This change introduces \CommentFactory\ for parsing documentation comments, \MemberLookup\ for resolving internal and external links (including improved JDK 11+ module support), \IndexModelFactory\ for generating the alphabetical index, and \TreeFactory\/\TypeEntity\ for handling code snippets and type representations. The \ModelFactory\ now acts as a central hub mixing in these traits, while \Entity\, \MemberEntity\, and \TemplateEntity\ provide a cleaner interface for modeling Scala declarations. This modularization improves maintainability and allows specific aspects of documentation generation to be extended or replaced independently.

src/scaladoc/scala/tools/nsc/doc/model · high confidence

Scaladoc source code moved to src/scaladoc

The Scaladoc implementation has been relocated from the main compiler source tree into a dedicated \src/scaladoc\ directory. This structural change organizes the documentation generation logic—including the \DocFactory\, \DocParser\, \ScaladocGlobal\, and related model components—into its own package (\scala.tools.nsc.doc\), separating it from the core compiler phases while maintaining its integration with the Scala compiler infrastructure.

src/scaladoc/scala/tools/nsc/doc · high confidence

Behavioural changes

102 commits (6 fixes) modifying src/compiler/scala/tools/nsc/transform/patmat

A change to existing behaviour in src/compiler/scala/tools/nsc/transform/patmat — 102 commits (6 fixs), 5 files: “Reworked MaybeTypedBound”; “move sat solving to separate file”; “Escape $ in docs for undefined variables”; and 92 more (refs \#5859).

src/compiler/scala/tools/nsc/transform/patmat · medium confidence · unverified

124 commits (7 fixes) modifying src/compiler/scala/tools/nsc/tasty/bridge

A change to existing behaviour in src/compiler/scala/tools/nsc/tasty/bridge — 124 commits (7 fixs), 6 files: “annotations use lazy val to compute tree”; “Ensure paths are preserved for type member selection”; “support Dotty 0.24.0-RC1”; and 117 more (refs \#25, \#12357).

src/compiler/scala/tools/nsc/tasty/bridge · medium confidence · unverified

17 commits (4 fixes) modifying src/testkit/scala/tools/testkit

A change to existing behaviour in src/testkit/scala/tools/testkit — 17 commits (4 fixs), 7 files: “CommandLineParser is process.Parser”; “"At least it's not a NRE"”; “minor cleanups”; and 14 more.

src/testkit/scala/tools/testkit · medium confidence · unverified

183 commits (12 fixes) modifying src/reflect/scala/reflect/internal/tpe

A change to existing behaviour in src/reflect/scala/reflect/internal/tpe — 183 commits (12 fixs), 5 files: “remove deprecated compiler flag "-Yeta-expand-keeps-star"”; “Reuse an instance of FindMember”; “Reuse an instance of a TypeCollector used in hot loop in LUBs”; and 171 more (refs \#5859).

src/reflect/scala/reflect/internal/tpe · medium confidence · unverified

2402 commits (437 fixes) modifying src/compiler/scala/tools/nsc/typechecker

A change to existing behaviour in src/compiler/scala/tools/nsc/typechecker — 2402 commits (437 fixs), 23 files: “\[backport\] SI-7756 Uncripple refchecks in case bodies”; “Import selector can be given”; “Relax -Xlint warning for implicit classes. Closes SI-5809”; and 2299 more (refs \#10919, \#1094, \#3667, \#2926, \#1459, …).

src/compiler/scala/tools/nsc/typechecker · medium confidence · unverified

333 commits (50 fixes) modifying src/compiler/scala/tools/nsc/ast

A change to existing behaviour in src/compiler/scala/tools/nsc/ast — 333 commits (50 fixs), 5 files: “More consistent use of Names”; “move synthetic case symbol detection to treeInfo”; “added support for notnull, first steps”; and 319 more (refs \#1342, \#4300, \#1263, \#1084, \#1611, …).

src/compiler/scala/tools/nsc/ast · medium confidence · unverified

35 commits (2 fixes) modifying src/compiler/scala/reflect/macros/compiler

A change to existing behaviour in src/compiler/scala/reflect/macros/compiler — 35 commits (2 fixs), 2 files: “Patvar tracking in functions, absolve element names, apply fixes”; “refactors macro compilation”; “macro impls can now return subtypes of c.Tree”; and 32 more.

src/compiler/scala/reflect/macros/compiler · medium confidence · unverified

370 commits (42 fixes) modifying src/reflect/scala/reflect/runtime

A change to existing behaviour in src/reflect/scala/reflect/runtime — 370 commits (42 fixs), 15 files: “synchronizes pendingVolatiles”; “improvements for reification of free symbols”; “Fix JavaUniverseForce”; and 352 more (refs \#5116, \#5859).

src/reflect/scala/reflect/runtime · medium confidence · unverified

42 commits (2 fixes) modifying src/compiler/scala/tools/nsc/classpath

A change to existing behaviour in src/compiler/scala/tools/nsc/classpath — 42 commits (2 fixs), 4 files: “Reduce scope of val and improve some names”; “Define interface for flat classpath and add package loader using it”; “Support Java 9 modular runtime images”; and 38 more.

src/compiler/scala/tools/nsc/classpath · medium confidence · unverified

47 commits (2 fixes) modifying src/interactive/scala/tools/nsc/interactive

A change to existing behaviour in src/interactive/scala/tools/nsc/interactive — 47 commits (2 fixs), 11 files: “More dry refactoring”; “Put all debug/developer behind an AlmostFinalValue false”; “Fix completion of x.bar.\<TAB\>, where bar takes dependent implicits”; and 39 more (refs \#5859).

src/interactive/scala/tools/nsc/interactive · medium confidence · unverified

57 commits (12 fixes) modifying src/scalap/scala/tools/scalap/scalax/rules/scalasig

A change to existing behaviour in src/scalap/scala/tools/scalap/scalax/rules/scalasig — 57 commits (12 fixs), 3 files: “More consistent use of Names”; “Fix scalap parsing/printing of enum and class constant types”; “Found there was still all kinds of detritus rem”; and 54 more (refs \#6285, \#3060, \#3128, \#2885, \#2747).

src/scalap/scala/tools/scalap/scalax/rules/scalasig · medium confidence · unverified

6936 commits (1129 fixes) modifying repository

A change to existing behaviour in repository — 6936 commits (1129 fixs), 157 files: “synchronizes pendingVolatiles”; “Gave Option its own nonEmpty”; “Scaladoc: Typers change”; and 6671 more (refs \#594, \#1196, \#1197, \#1203, \#3737, …).

repository · medium confidence · unverified

99 commits (8 fixes) modifying src/compiler/scala/tools/nsc/backend/jvm/opt

A change to existing behaviour in src/compiler/scala/tools/nsc/backend/jvm/opt — 99 commits (8 fixs), 3 files: “Reduce scope of val and improve some names”; “\[backport\] Follow JDK 11+ spec for signature polymorphic methods”; “Store source file paths of classes being compiled in the bytecode repo”; and 96 more (refs \#6733).

src/compiler/scala/tools/nsc/backend/jvm/opt · medium confidence · unverified

Add @uncheckedBounds annotation and deprecate internal alias

The compiler now includes a new @uncheckedBounds annotation that allows developers to suppress type parameter bound checks during the refchecks phase, which is useful for synthesized code using inferred types. Additionally, the internal scala.reflect.internal.annotations.compileTimeOnly type alias has been deprecated in favor of the standard scala.annotation.compileTimeOnly.

src/reflect/scala/reflect/internal/annotations · high confidence

Async transform refactored into a macro and post-erasure phase

The \async\ compiler phase has been restructured to implement the transformation using a macro combined with a post-erasure phase. This change introduces new internal components in \src/compiler/scala/tools/nsc/transform/async\ to handle the transformation pipeline, including \AnfTransform\ for converting code to A-Normal Form, \AsyncAnalysis\ for detecting unsupported \await\ usage, \AsyncNames\ for name management, and \Lifter\/\LiveVariables\ for optimizing state machine fields. Users benefit from improved integration with compiler front-end macros, better handling of nested control flow, and more deterministic compiler output.

src/compiler/scala/tools/nsc/transform/async · high confidence

Automated initialization of GPG credentials and SBT plugins for release builds

A new admin/init.sh script has been added to streamline the setup of release artifacts. When the GPG\_ENC\_PASS environment variable is present, the script automatically decrypts the GPG key and processes private repository credentials, then copies the necessary GPG configuration file into the SBT plugins directory. This ensures that the build environment is correctly configured for signed releases without manual intervention.

admin · high confidence

BeanProperty annotations now document Scala 3 visibility differences

The \BeanProperty\ and \BooleanBeanProperty\ annotations in \scala.beans\ have been updated to clarify that while they continue to generate Java Bean-style getters and setters, their visibility differs between Scala versions: in Scala 2 the generated methods are visible from both Scala and Java, but in Scala 3 they are only visible from Java (including via Java reflection). This change ensures users are aware of the behavioral difference when migrating or using these annotations in Scala 3 contexts.

src/library/scala/beans · high confidence

Compiler utility package refactored and rewritten in Scala

The \scala.tools.nsc.util\ package has been significantly restructured, with core components such as \CharArrayReader\, \ClassPath\, \DocStrings\, \EditDistance\, \Exceptional\, \InterruptReq\, \JarFactory\, \ShowPickled\, \SimpleTracer\, \StackTracing\, \StringUtil\, and \WorkScheduler\ rewritten in Scala. This change introduces new abstractions for classpath handling (including \EfficientClassPath\ and \EfficientClassPathCallBack\), modernizes the interrupt request mechanism for the presentation compiler, and adds utilities for stack trace formatting and string manipulation. Deprecated type aliases and values from older Scala versions (2.10 and 2.11) have been retained in the package object for backward compatibility with tools like sbt and scala-refactoring.

src/compiler/scala/tools/nsc/util · high confidence

Complete rewrite of the Scala collections library

The \scala.collection\ package has been completely rewritten to introduce a new, unified collection hierarchy. This change replaces the previous \Traversable\/\GenTraversable\ model with a new structure based on \IterableOnce\, \Iterable\, and specific operation traits (e.g., \IterableOps\, \SeqOps\, \IndexedSeqOps\). Key additions include the \BuildFrom\ type class for context-aware collection construction, the \Factory\ trait for building collections, and the \Stepper\ API for efficient parallel processing. Existing types like \ArrayOps\, \BitSet\, and \IndexedSeq\ have been re-implemented to fit this new architecture, and many legacy methods and traits have been deprecated or removed.

src/library/scala/collection · high confidence

Concurrent map API and implementation refactored to Java

The \scala.collection.concurrent\ package has been restructured: the core \Map\ trait is now implemented in Scala but relies on new Java-based internal node classes (\BasicNode\, \CNodeBase\, \INodeBase\, \MainNode\) for atomic operations, while the \Gen\ class is introduced as a generation marker. The \Map\ trait now explicitly defines atomic operations like \putIfAbsent\, \remove\, and \replace\, and implements \getOrElseUpdate\ and \updateWith\ using reference-equality helpers (\removeRefEq\, \replaceRefEq\) to ensure thread-safe updates.

src/library/scala/collection/concurrent · high confidence

Deprecation of scala.compat.Platform

The \scala.compat.Platform\ object and its members (including \arraycopy\, \createArray\, \EOL\, \currentTime\, and others) are now deprecated as of version 2.13.0 and will be removed in a future release. Users should migrate to the corresponding standard Java APIs, such as \java.lang.System.arraycopy\, \java.lang.reflect.Array.newInstance\, and \java.lang.System.lineSeparator\.

src/library/scala/compat · high confidence

Extract common XML parsing logic into shared compiler and library components

The XML parser implementation in the Scala compiler has been refactored to share code with the standard library. New files \MarkupParserCommon.scala\ and \Utility.scala\ have been added to \src/compiler/scala/tools/nsc/ast/parser/xml\ to house common parsing utilities (such as character reference parsing, name validation, and attribute handling) and a shared trait. This change removes the compiler's direct dependency on the external \scala-xml\ library for these core parsing tasks, aligning the compiler's internal parser with the library's implementation.

src/compiler/scala/tools/nsc/ast/parser/xml · high confidence

Immutable collection classes restructured for Scala 2.13

The immutable collection library has been significantly restructured to support the new Scala 2.13 collections API. Key changes include the introduction of \ArraySeq\ as an immutable array-backed sequence, the adoption of \SeqMap\ (renamed from \LinkedMap\) for insertion-ordered maps, and the implementation of \LazyList\ (replacing \Stream\) with a fully lazy, thread-safe design using \AtomicReferenceFieldUpdater\. Additionally, \BitSet\ and \ChampCommon\ (underlying \HashMap\/\HashSet\) have been updated to align with the new trait-based architecture, including specific optimizations for small bitsets and hash-trie iterators.

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

InteractiveReader deprecated as compatibility stub for sbt

The InteractiveReader object has been replaced with a deprecated compatibility stub that returns null, signaling the removal of the embedded JLine dependency and the split of the REPL into front/back components. Users relying on this class for sbt console integration should migrate to the new classes in the scala.tools.nsc.interpreter package.

src/repl-frontend/scala/tools/nsc/interpreter · high confidence

Introduce Scala-managed Scala tool man pages

The manual pages for the core Scala tools (scala, scalac, scaladoc, fsc, and scalap) are now generated from Scala source files in src/manual/scala/man1. This change standardizes the documentation format, ensures the man pages are kept in sync with the actual command-line options, and updates the content to reflect current tool behavior, such as the use of the compilation daemon (fsc) and Java 8 targeting.

src/manual/scala/man1 · high confidence

Introduce Scalax rules engine for Scala signature parsing

The Scala signature parser (scalap) now uses the Scalax rules library to handle parsing logic. This change introduces a new rule-based DSL (including traits like Rule, Rules, and SeqRule) that allows for more composable and maintainable parsing definitions, replacing the previous ad-hoc parsing implementation.

src/scalap/scala/tools/scalap/scalax/rules · high confidence

Introduces fast-track macro expansion for string interpolators and quasiquotes

The compiler now includes a 'FastTrack' mechanism in the reflection package that bypasses standard reflective invocation for specific system macros, including the \s\, \raw\, and \f\ string interpolators, as well as quasiquotes and type tag materialization. By hardwiring these macros directly to their implementations, the compiler avoids the overhead of Java/Scala reflection, resulting in faster macro expansion. This change also introduces a \FastStringInterpolator\ trait that handles the constant-folding and escape processing for \s\ and \raw\ interpolators, and integrates with the \ToolBox\ infrastructure to support these optimizations in runtime reflection contexts.

src/compiler/scala/tools/reflect · high confidence

Introduction of Erasure and PostErasure transform phases

The compiler now includes dedicated \Erasure\ and \PostErasure\ transformation phases within the reflect internal API. The \Erasure\ trait handles the removal of generic type information, including specific logic for value classes, arrays, and Java/Scala interoperability, while \PostErasure\ cleans up erased value types. These phases are wired into the type transformation pipeline via \Transforms.scala\, allowing the compiler to correctly process types through uncurrying, erasure, and post-erasure steps.

src/reflect/scala/reflect/internal/transform · high confidence

Introduction of new macro runtime infrastructure

The macro runtime subsystem has been restructured with the addition of new files in \scala.reflect.macros.runtime\. This includes \AbortMacroException\ for handling macro expansion failures, \JavaReflectionRuntimes\ for resolving macro implementations via Java reflection (supporting both bundle and singleton patterns), and \MacroRuntimes\ which provides the core logic for caching and resolving macro runtimes, including a dedicated classloader cache. A \package.scala\ file also exposes the \Context\ type alias.

src/compiler/scala/reflect/macros/runtime · high confidence

Macros context API restructured into specialized traits

The \scala.reflect.macros\ package has been reorganized to improve API clarity and usability. The macro context (\blackbox.Context\) is now composed of distinct traits—such as \Aliases\, \Enclosures\, \Evals\, \ExprUtils\, \FrontEnds\, \Internals\, \Names\, \Parsers\, \Reifiers\, and \Typers\—each exposing a specific subset of functionality. This change introduces convenient shorthands for common types and operations (e.g., \typeOf\, \weakTypeTag\, \freshName\) and deprecates older, less precise APIs like \c.fresh\ and \c.enclosingTree\-style methods in favor of more robust alternatives. Additionally, the \Attachments\ system has been refined to support type-indexed metadata storage on symbols and trees, and internal compiler interactions are now accessed via the \c.internal\ API.

src/reflect/scala/reflect/macros · high confidence

Major refactoring of compiler transform phases

The compiler's transform pipeline has been significantly restructured. The \Erasure\ phase now extends \InfoTransform\ and integrates with \TypeAdaptingTransformer\ to handle type erasure and signature generation more robustly. \ExplicitOuter\ has been updated to manage outer pointers for inner classes, including logic to reuse parent outer fields where possible. A new \ExtensionMethods\ phase has been introduced to generate extension methods for value classes, ensuring they are accessible and correctly typed. Additionally, the \Fields\ phase now synthesizes accessors, fields, and bitmaps for lazy vals and modules, implementing double-checked locking for thread safety and handling module var mixing for traits.

src/compiler/scala/tools/nsc/transform · high confidence

Major refactoring of mutable collection implementations

The mutable collection library has been significantly restructured and optimized. Key changes include the introduction of specialized implementations like AnyRefMap (now deprecated in favor of HashMap), ArrayDeque, and ArraySeq, alongside major performance improvements and bug fixes in core classes such as ArrayBuffer, BitSet, and Builder. The refactoring also standardizes interfaces, improves serialization handling, and enhances type safety across the mutable collection hierarchy.

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

New compiler utility classes for path resolution and safe exit handling

The compiler now includes new utility classes in \scala.tools.util\ to improve classpath resolution and error handling. \PathResolver\ provides a dedicated implementation for resolving classpaths based on environment variables and system properties, replacing previous ad-hoc logic. \SystemExit\ replaces direct calls to \System.exit\ with a \ControlThrowable\, allowing the compiler to handle termination more gracefully without forcibly killing the JVM. Additionally, \VerifyClass\ offers a tool for validating class files in JARs or directories, primarily for use by build tools like sbt or Ant.

src/compiler/scala/tools/util · high confidence

New reification error handling and pipeline structure

The reifier now uses a dedicated \Errors\ trait to provide specific, user-friendly error messages for common reification failures (such as attempting to reify weak types, runtime splices, or erroneous prefixes) instead of generic crashes. It also introduces a structured \Phases\ pipeline (calculate, reshape, metalevels, reify) to manage the reification process more robustly, and encapsulates mutable state in a \State\ class to prevent desyncs during nested reifications.

src/compiler/scala/reflect/reify · high confidence

Overhaul of scala.io library with new AnsiColor, Codec, and BufferedSource implementations

The scala.io package has been significantly restructured and expanded. A new AnsiColor trait provides constants for ANSI escape codes to control text formatting and colors in terminal output. The Codec class has been rewritten to use java.nio.charset for encoding and decoding, offering configurable error handling for malformed input and unmappable characters, along with migration annotations for the renamed fromUTF8 and toUTF8 methods. BufferedSource now implements a more robust buffering strategy using a shared reader to prevent data loss between iter and getLines, and Source gains new convenience methods like stdin and fromResource, while also implementing java.io.Closeable.

src/library/scala/io · high confidence

REPL architecture modularized with presentation compiler integration

The REPL has been refactored into distinct components (IMain, ExprTyper, MemberHandlers, Naming, Power, PresentationCompilation) to separate the interpreter logic from the compiler and shell. This change introduces a presentation compiler for tab completion and type checking, improves error handling for compiler initialization failures, and adds support for class-based REPL wrappers via the -Yrepl-class-based flag.

src/repl · high confidence

REPL now respects deprecation and feature settings by default

The Scala REPL (read-eval-print loop) has been refactored to explicitly enable the -deprecation and -feature compiler flags when the user has not explicitly configured -Wconf or -Xlint. This ensures that users see deprecation warnings and feature warnings during interactive sessions unless they have opted out via these specific configuration flags, improving visibility into deprecated APIs and language features.

src/repl-frontend/scala/tools/nsc · high confidence

REPL switches to JLine 3

The Scala REPL now uses JLine 3 instead of the previous JLine 2 implementation. This upgrade brings improved line editing, tab completion with typo tolerance and camel-case matching, and better history management. Users will experience more robust input handling, including support for .inputrc configuration files, disabled event expansion to prevent escape sequence issues, and a new Ctrl+Alt+T shortcut to show the type of the expression at the cursor.

src/repl-frontend/scala/tools/nsc/interpreter/jline · high confidence

Refactor annotation hierarchy and introduce @nowarn

The \scala.annotation\ package has been restructured to introduce \ConstantAnnotation\ as a new base trait for annotations that accept only constant arguments (extending \StaticAnnotation\), while \ClassfileAnnotation\ is now deprecated in favor of Java-based annotations for classfile persistence. Several existing annotations, including \@elidable\, \@implicitAmbiguous\, \@implicitNotFound\, and \@nowarn\, now extend \ConstantAnnotation\ to enforce constant argument constraints. A new \@nowarn\ annotation is added to allow local suppression of compiler warnings with optional filtering. Additionally, \@showAsInfix\, \@strictfp\, and \@unspecialized\ are marked as deprecated for inheritance to prepare for future finalization.

src/library/scala/annotation · high confidence

Refactored TASTy unpickling with explicit mode tracking and debugging

The TASTy reader in the Scala 2 compiler has been refactored to improve reliability and debuggability when reading Scala 3 bytecode. A new \TastyModes\ system now explicitly tracks the context of unpickling operations (such as reading annotations, macro bodies, or Java enums), allowing the reader to handle these structures correctly. Additionally, a \ForceKinds\ bitset has been introduced to track why symbols are being forced, providing detailed diagnostic information to help resolve issues related to symbol initialization and class loading.

src/compiler/scala/tools/nsc/tasty · high confidence

Refactored classfile reading and pickling infrastructure

The classfile reading and pickling subsystem has been restructured to improve performance and maintainability. A new \DataReader\ trait and its \AbstractFileReader\ and \ReusableDataReader\ implementations replace the previous byte-reading logic, enabling more efficient buffer reuse and cleaner separation of concerns. The \Pickler\ component has been refactored to integrate with this new reading infrastructure, ensuring that symbol data is serialized and deserialized with optimized buffer handling. This change impacts how the compiler reads class files and writes pickle data, potentially affecting compilation performance and stability for large codebases.

src/compiler/scala/tools/nsc/symtab/classfile · medium confidence

Refactored compiler reporter architecture with new FilteringReporter and ConsoleReporter

The compiler's reporting subsystem has been restructured to improve modularity and compatibility with build tools like sbt. A new \FilteringReporter\ abstract class now handles message deduplication and count limits (via \-Xmaxerrs\/\-Xmaxwarns\), while \ConsoleReporter\ provides the standard text output. New \ForwardingReporter\ and \MakeFilteringForwardingReporter\ classes allow external tools to wrap or replace the default reporter without breaking internal filtering logic. \StoreReporter\ has been updated to store \CodeAction\ data alongside messages, and \NoReporter\ provides a silent option. These changes standardize how errors, warnings, and suggestions are processed and displayed.

src/compiler/scala/tools/nsc/reporters · high confidence

Refactored scala.math library with new BigInt/BigDecimal implementations and Equiv typeclass

The \scala.math\ package has been restructured, introducing new implementations for \BigInt\ (optimized with a Long-based cache for small values) and \BigDecimal\ (with explicit \decimal\/\binary\/\exact\ construction methods and \RoundingMode\ enumeration). A new \Equiv\[T\]\ typeclass has been added to represent equivalence relations, replacing the universal \Equality\ with explicit \Equiv.universal\ usage and providing specialized \Float\/\Double\ equivalences (\StrictEquiv\ vs \IeeeEquiv\). The \Ordering\ trait now extends \PartialOrdering\ and \Equiv\, and \Numeric\/\Fractional\/\Integral\ traits have been refined with dedicated \Ops\ classes and \Implicits\ objects to manage infix operator visibility.

src/library/scala/math · high confidence

Refactored scala.reflect.io with new NIO-based file abstractions

The \scala.reflect.io\ package has been significantly restructured to introduce a unified \AbstractFile\ abstraction and new implementations for handling file system resources. This change adds \PlainNioFile\ to leverage Java NIO for file I/O, introduces \RootPath\ to manage JAR and directory roots with proper resource closing, and adds \VirtualFile\ and \VirtualDirectory\ for in-memory file handling. The refactoring also includes a new \Path\ abstraction to distinguish between files, directories, and generic paths, and updates \ZipArchive\ to support modular runtime images and multi-release JARs. These changes improve performance, resource management, and compatibility with modern Java platforms within the reflection and compiler libraries.

src/reflect/scala/reflect/io · high confidence

Refactored settings abstraction and deprecated implicit boolean conversion

The settings subsystem in \scala-reflect\ has been restructured with new \AbsSettings\ and \MutableSettings\ traits that introduce a generic \SettingValue\ type with explicit \value\ accessors, replacing previous implicit conversions. This change deprecates the implicit conversion of \BooleanSetting\ to \Boolean\ (which caused boxing overhead) in favor of accessing \setting.value\ directly, and adds helper methods like \areStatisticsEnabled\ and \isDebug\ to \MutableSettings\ for more efficient checks.

src/reflect/scala/reflect/internal/settings · high confidence

Refactored system properties and environment access with new Prop abstraction

The \scala.sys\ package has been restructured to provide a more robust and type-safe way to interact with system properties and environment variables. A new \Prop\ trait and its implementations (\BooleanProp\, \PropImpl\) replace the previous ad-hoc property handling, allowing users to access properties with specific type conversions (e.g., \Int\, \Double\, \File\) and boolean-specific semantics (e.g., \valueIsTrue\ vs \keyExists\). The \SystemProperties\ class now implements \mutable.Map\[String, String\]\ for bidirectional access to Java system properties, with security exceptions handled gracefully. Additionally, \scala.sys.env\ now provides a map-like interface to environment variables that falls back to case-insensitive lookup on platforms where necessary, and \addShutdownHook\ returns a \ShutdownHookThread\ that can be explicitly removed.

src/library/scala/sys · high confidence

Reimplementation of Scala Futures and Promises with Java 8 Compatibility

The internal implementation of \scala.concurrent.Future\ and \Promise\ has been rewritten to improve performance, correctness, and interoperability with Java 8. This change introduces a new \ExecutionContextImpl\ that configures the global execution context via system properties (e.g., \scala.concurrent.context.minThreads\) and supports managed blocking via \ForkJoinPool.ManagedBlocker\. The \Promise\ implementation now uses a \CompletionLatch\ and optimized link compression to reduce memory leaks and improve inlining, while also enforcing stricter exception handling by wrapping \ControlThrowable\ and \InterruptedException\. Additionally, \FutureConvertersImpl\ provides bidirectional conversion between Scala \Future\ and Java \CompletableFuture\, allowing Scala futures to be used seamlessly in Java 8+ environments.

src/library/scala/concurrent/impl · high confidence

Reintroduces reification code generation traits

The reifier's code generation logic is now implemented via a set of new traits (GenAnnotationInfos, GenNames, GenPositions, GenSymbols, GenTrees, GenTypes, and GenUtils) within the \scala.reflect.reify.codegen\ package. This change restores the ability to convert Scala reflection trees and types into runtime-representable mirror calls, including specific handling for annotation info reification, symbol table management for free variables, and type splicing via TypeTags or manifests.

src/compiler/scala/reflect/reify/codegen · high confidence

Repackaged fsc compiler daemon into scala.tools.nsc.fsc

The fast Scala compiler (fsc) client and server components have been moved into the \scala.tools.nsc.fsc\ package. This refactoring reorganizes the \CompileClient\, \CompileServer\, \CompileSocket\, \FscSettings\, and related socket handling classes, but preserves the existing offline compilation behavior and command-line interface.

src/compiler/scala/tools/nsc/fsc · high confidence

Scaladoc diagrams now render dynamically in the browser using dagre-d3

The Scaladoc diagram generator has switched from pre-generating static SVGs with Graphviz to producing DOT source code that is rendered client-side by the dagre-d3 library. This change introduces interactive features such as zooming and panning for inheritance and package diagrams, and updates the HTML structure to include script tags that initialize the d3-based renderer on the page. The underlying implementation now relies on JavaScript execution within the browser to construct the visual graph from the DOT data, replacing the previous server-side static image generation approach.

src/scaladoc/scala/tools/nsc/doc/html/page/diagram · high confidence

Scaladoc now exits with non-zero status on errors

The Scaladoc tool now correctly returns a non-zero exit code when documentation generation fails, aligning with its documented behavior. This change ensures that build scripts and CI pipelines can reliably detect documentation errors by checking the process exit status, rather than relying solely on stdout/stderr output.

src/scaladoc/scala/tools/nsc · high confidence

Scaladoc receives a complete visual and functional overhaul

The Scaladoc HTML resource files have been replaced with a new design, introducing a modern look and feel with updated CSS (index.css, template.css, diagrams.css) and new SVG icons for entities like classes, objects, and annotations. This change also brings functional improvements to the documentation viewer, including a new search interface with keyboard navigation, support for inheritance diagrams with pan/zoom capabilities, and fixes for cross-browser compatibility issues such as permalink handling and scroll behavior.

src/scaladoc/scala/tools/nsc/doc/html/resource · high confidence

Scalap rewritten with new classpath handling and annotation-based Scala signature support

The scalap tool has been refactored to use the modern Scala classpath infrastructure (scala.tools.nsc.classpath) instead of its previous internal implementation, allowing it to leverage standard Scala compiler classpath resolution. Additionally, scalap now supports the newer ScalaSignature annotation format (Lscala/reflect/ScalaSignature;) in addition to the legacy ScalaSig attribute, ensuring compatibility with recent Scala compiler output. The command-line interface remains largely the same, supporting -cp/-classpath, -private, -verbose, and -version flags, but the underlying parsing and decoding logic has been significantly restructured for maintainability and correctness.

src/scalap/scala/tools/scalap · high confidence

Standard library restructured with new AnyVal hierarchy and generated primitive types

The standard library in \src/library/scala\ has been reorganized to introduce a new \AnyVal\ abstract class as the root for all value types, along with a new \AnyValCompanion\ trait for primitive companions. Primitive types such as \Boolean\, \Byte\, \Char\, and \Double\ are now implemented as auto-generated source files (managed by \GenerateAnyVals.scala\) that extend \AnyVal\. Additionally, the \App\ trait has been updated to explicitly extend \DelayedInit\ and include deprecation warnings regarding its reliance on delayed initialization, while \Array\ gains new factory and conversion methods like \from\ and \toFactory\.

src/library/scala · high confidence

TASTy reader upgraded to support Scala 3.7 (format 28.7)

The TASTy reader in the compiler now supports the TASTy format version 28.7, which is the final supported version for the 28.x series. This update allows the compiler to read class files compiled with Scala 3.7, while maintaining backward compatibility with earlier minor versions in the 28.x series. The reader also enforces strict version compatibility checks, ensuring that experimental TASTy files are only read by compilers with matching experimental versions, and providing clear error messages and fix suggestions when version mismatches occur.

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

Updated SBT PGP plugin and added private repository credentials

The release signing process now uses the sbt-pgp plugin version 2.3.1, replacing the previous version. Additionally, credentials for the private repository at scala-ci.typesafe.com have been added to support authenticated access during the build process.

admin/files · high confidence

Updated distribution documentation and license files

The documentation folder now includes a new README for the Scala distribution, clarifying that Java 1.8 or above is required and listing available tools like the REPL, compiler, and scaladoc. The license information has been updated to reflect the Apache License 2.0, with copyright years extended to 2026 for EPFL and Lightbend, Inc. dba Akka, and third-party licenses for JLine 3, ASM, and jQuery are explicitly documented in both Markdown and RTF formats.

doc · high confidence

Updated shell and batch launchers for Windows compatibility and stability

The Unix and Windows launcher scripts have been updated to improve compatibility and reliability on Windows environments. The Unix template now explicitly detects and handles Cygwin, MinGW, and MSYS environments, applying \cygpath\ conversions to paths and classpaths to ensure correct execution. The Windows batch file has been modified to disable delayed expansion during the final Java executable call to prevent issues with exclamation marks in quoted strings, and it now correctly captures and returns the process exit code.

src/compiler/templates · high confidence

Zinc compiler bridge refactored into new modular phase architecture

The sbt-bridge implementation has been restructured to improve incremental compilation performance and stability. A new API extraction phase (API.scala) now runs after the pickler to construct public API representations, enabling the incremental algorithm to operate independently of the compiler pipeline and allowing subsequent compilations to start before the initial one finishes. The Analyzer phase (Analyzer.scala) has been updated to correctly locate generated class files in both plain directories and JARs, while the CallbackGlobal (CallbackGlobal.scala) now orchestrates these phases and handles compatibility with older AnalysisCallback versions to prevent NoClassDefFoundErrors. Additionally, AbstractZincFile (AbstractZincFile.scala) provides a unified abstraction for virtual files, and ExtractUsedNames (ExtractUsedNames.scala) has been refined to correctly track name usage scopes, including pattern matching targets.

src/sbt-bridge · high confidence

Test coverage

1 commit adding/updating tests in (repo-wide); 1 commit adding/updating tests in test/files/pos/annot-default-literal-type; 1 commit adding/updating tests in test/files/pos/super-java-default-stop-after; 1 commit adding/updating tests in test/files/pos/t13175; 3037 commits adding/updating tests in test/files/run; Added JUnit test coverage for immutable collections; Added JUnit test suite for Scala collection operations; Added JUnit test suite for core Scala library components; Added JUnit tests for JVM backend bytecode generation and optimization; Added JUnit tests for JVM backend optimizer components; Added JUnit tests for REPL completion, scripting, and tabulation; Added JUnit tests for Scala Regex matching behavior; Added JUnit tests for Scala annotation bytecode generation and runtime retention; Added JUnit tests for Scala language enrichment methods; Added JUnit tests for Scaladoc HTML generation; Added JUnit tests for StringContext and string interpolation; Added JUnit tests for collection conversion wrappers; Added JUnit tests for internal utility classes; Added JUnit tests for reflect/internal components; Added JUnit tests for scala.io.Source; Added JUnit tests for scala.jdk conversion and stepper utilities; Added JUnit tests for scala.util utilities; Added JUnit tests for the NSC typechecker; Added JUnit tests for the Scala compiler symbol table; Added JUnit tests for the nsc.transform package; Added JUnit-based test harness for TASTy validation; Added JVM-specific test suite for annotations, concurrency, and standard library types; Added JVM-specific tests for the async compiler plugin; Added Java test fixtures for TASTy pipelined compilation; Added Java tests for scala.jdk.javaapi converters; Added OSGi integration tests for Scala; Added QUnit tests for ScalaDoc index page filtering; Added ScalaCheck property tests for collection parsing, views, and iterators; Added ScalaCheck tests for Java collection wrapper behavior; Added Scalacheck property tests for mutable collections; Added Scalacheck test suite for Scaladoc; Added Scaladoc model tests for AnyRef, canonical URLs, diagrams, and implicits; Added Scaladoc test resources for Scala core types; Added TASTY test infrastructure and specific test cases; Added TASTy pipelined compilation tests for Java interop features; Added TASTy positive tests for Scala 3 annotations and language features; Added TASTy reader test suite for Scala 2 compatibility; Added TastyTest test infrastructure and shim layer; Added benchmarks for equality operations; Added bytecode and logic tests for pattern matching optimizations; Added comprehensive property-based tests for Scala standard library collections; Added comprehensive test suite for -Xasync compiler flag; Added instrumentation tests for compiler optimizations; Added jcstress concurrency tests for Scala collections; Added negative test cases for compiler warnings and errors; Added negative test suite for Scala 3 intent library macros; Added negative test suite for TASTy printing; Added negative tests for Scala 3 language features; Added negative tests for TASTy interop with Java enums, deprecation, and type bounds; Added negative tests for TASTy unpickling limitations; Added negative tests for async await validation; Added parser position regression tests; Added position tests for various Scala syntax constructs; Added positive regression tests for Jsoup cycle handling; Added positive test cases for Java 8 interface features; Added positive test cases for Java access modifier interoperability; Added positive test cases for Scala-Java interop scenarios; Added positive test cases for Scala-Java interoperability; Added positive test cases for Scala/Java interop and import scoping; Added positive test cases for Scala/Java interop and type inference; Added positive test cases for implicit conversions in package objects; Added positive test cases for procedure syntax deprecation; Added positive test cases for trait method invocation with generic parameters; Added positive test cases for tuple enrichment traits (t3864); Added positive test for HashMap instantiation; Added positive test for SI-4365 nondeterministic failure in asSeenFrom; Added positive test for SI-7596 symbol curtailment during unpickling; Added positive test for object in trait mixed into package object; Added positive tests for Java import vs definition binding precedence; Added presentation compiler test suite for scope completion, hyperlinks, and doc comments; Added presentation tests for implicit member resolution and IDE bug 1000475; Added property-based tests for Accumulator conversions and draining; Added property-based tests for BigInt; Added property-based tests for Scala Array and Option; Added property-based tests for Scala quasiquotes; Added regression and positive tests for Scala compiler features; Added regression test for Java List interoperability; Added regression test for SI-3936; Added regression test for Scala annotation type mismatch with Java; Added regression test for cyclic reference handling; Added regression test for issue \#2464; Added regression test for issue SI-942; Added regression test for macro changeOwner behavior; Added regression test for macro incoherent tree crash; Added regression test for macro type bounds with TwoFaceInt; Added regression test for protected field access across packages; Added regression test for scaladoc and tasty; Added regression test for silent type-checking in macros; Added regression tests for Java enum interoperability; Added regression tests for Java inner class file reading; Added regression tests for Java wildcard bound inference; Added regression tests for Java/Scala interop with primitive and boxed Long types; Added regression tests for SI-10159 spurious cyclic error; Added regression tests for SI-2458 regarding BitSet name shadowing; Added regression tests for SI-5545; Added regression tests for SI-7596 symbol overloading during unpickling; Added regression tests for Scala annotation processing with Java interfaces; Added regression tests for Scala issue SI-4744 cycle handling; Added regression tests for Scala-Java interoperability with nested interfaces; Added regression tests for Scala-Java visibility interaction (SI-6245); Added regression tests for Scala/Java interop with raw Function1 types; Added regression tests for annotated type pickling; Added regression tests for annotation argument evaluation; Added regression tests for blackbox macro type argument instantiation; Added regression tests for compiler issues; Added regression tests for empty package and DottyIterable type constraints; Added regression tests for eta expansion with local owner binders; Added regression tests for existential type handling in Java-Scala interop; Added regression tests for issue \#3951; Added regression tests for issue SI-5644; Added regression tests for macro expansion with named arguments; Added regression tests for nullary override warnings; Added regression tests for package object deferred load bug; Added regression tests for pattern matching and Java interop; Added regression tests for sealed class pickling; Added regression tests for static forwarder generation; Added regression tests for super type handling; Added runtime boxing and lambda deserialization tests; Added scalap regression tests for Scala language features; Added script test for manifest-based class-paths; Added scripted tests for API info and source dependencies; Added scripted tests for incremental compilation and API analysis; Added spec generation assets for numbering, TOC, and version notices; Added test case for Java interop type mismatch in generic inner classes; Added test case for Java interop with nested classes; Added test case for Scala trait annotated with Java annotation containing enum values; Added test case for issue \#3249; Added test case for macro expansion with implicits; Added test case for mixin abstract member access; Added test cases for Java annotation parsing and Scala syntax invariants; Added test cases for Java/Scala generic type bounds and Scala collection imports; Added test cases for cyclic reference handling; Added test cases for issue \#2940; Added test cases for private value class constructor access; Added test cases for type bounds and refined type aliases; Added test cases for unused macro warnings; Added test coverage for CONSTANT\_Dynamic constant pool handling; Added test coverage for JEP 445 compact compilation units; Added test coverage for Java enum access from Scala; Added test coverage for Java generic class inheritance and pickle-java option; Added test coverage for Java generic signature handling with traits extending classes; Added test coverage for Java protected inner class access restrictions; Added test coverage for Java type-use annotations; Added test coverage for Java-Scala interop with forwarders; Added test coverage for SI-9111 inliner workaround; Added test coverage for Scala child class overriding Java varargs method; Added test coverage for Scala class overriding Java abstract method with raw type; Added test coverage for Scala-Java generic inheritance interaction; Added test coverage for Scala-Java interop with Java lookup rules; Added test coverage for Scala-Java interoperability with linting; Added test coverage for Scala-Java static member lookup; Added test coverage for case class implicit parameters and macro annotations; Added test coverage for classOf with object types; Added test coverage for concurrent map operations and null value handling; Added test coverage for fplib Show API/Impl structure; Added test coverage for given class instances; Added test coverage for inline pattern selection with subcolon options; Added test coverage for issue \#1409; Added test coverage for macro expansion and annotated originals; Added test coverage for macro expansion with unused import warnings; Added test coverage for macro handling of deprecated type annotations; Added test coverage for pattern match unreachability analysis; Added test coverage for protected object member access; Added test coverage for refined type normalization (SI-5703); Added test coverage for the -Ystop-after:parser compiler flag; Added test coverage for the no-annotations flag behavior; Added test files for ScalaNumber and ScalaNumericConversions; Added test filters and gitignore for Scaladoc tests; Added test fixture for presentation server random client/server scenario; Added test for IDE crash on load with Java/Scala interop; Added test for Java access boundary checks between protected members; Added test for Java annotation enum handling in separate compilation; Added test for Java calling Scala HashMap; Added test for Java enum deprecation handling; Added test for Java field/method name collision with pickle-java; Added test for Java imports competing with level 4 definitions; Added test for Java inherited type handling in Protobuf; Added test for Java inner class selection detection; Added test for Java interface override with covariant return types; Added test for Java interoperability with Scala collections; Added test for Java static name resolution ambiguity; Added test for Java type handling in override checks; Added test for SI-8352 macro procedure syntax; Added test for Scala Nothing type resolution in mirror classes; Added test for Scala-Java varargs interoperability; Added test for annotated tree copying in macros; Added test for constant literal annotation arguments; Added test for delambdafy method transformation; Added test for idempotent presentation compilation of implicit classes; Added test for import ambiguity handling in same package; Added test for macro annotation deprecation warnings; Added test for macro literal reset behavior; Added test for parsing concrete private interface methods; Added test for pattern matching on large Java enums; Added test for private symbol import accessibility; Added test for secondary constructors in macros; Added test for shadowed import warning; Added test for static Java member accessibility; Added test for static import from Java subclass; Added test for throwing null in bytecode generation; Added test for trait linearization with subclassing; Added test for unpickling local sealed children; Added test infrastructure files for filtering and ignoring artifacts; Added test infrastructure for callcc-interpreter and ping-pong examples; Added test suite for Scala compiler plugin scanning; Added test suite for the Scala compiler bridge; Added tests for -Yimports implicit preamble imports; Added tests for @deprecated annotation awareness in inheritance and overriding; Added tests for DefaultPromise linking and completion behavior; Added tests for Duration serialization and string parsing; Added tests for Future failure-fast behavior, memory leaks, and blocking interactions; Added tests for JDK 16 record support in the Java parser; Added tests for Java 17+ sealed classes and pattern matching; Added tests for Java annotation array parsing; Added tests for Java annotation handling and Scala test suite composition; Added tests for Java annotation implementation handling; Added tests for Java annotation parsing; Added tests for Java annotation processing with enum values; Added tests for Java annotations on wildcard type arguments; Added tests for Java class literals on raw types; Added tests for Java enum constants in annotations; Added tests for Java field non-overriding behavior; Added tests for Java import shadowing behavior; Added tests for Java interop with Any/Object and wildcards; Added tests for Java member lookup in inherited types; Added tests for Java protected inner classes and modules; Added tests for Java protected static member access in Scala; Added tests for Java raw type parent handling; Added tests for Java signature generation in nested and local contexts; Added tests for Java type annotations on type parameters and array dimensions; Added tests for Java type imports; Added tests for Java varargs interoperability in Scala; Added tests for Java varargs overload resolution; Added tests for Java/Scala interop unification of Object and Any; Added tests for Map trait and Java interoperability; Added tests for MurmurHash3 consistency and range alignment; Added tests for SI-8947 macro tag materializer cross-talk; Added tests for Scala 2 intersection type erasure with value class parameters; Added tests for Scala annotation handling with Java annotation definitions; Added tests for Scala case classes using Java existential types; Added tests for Scala enum matching against Java abstract enum methods; Added tests for Scala version parsing, settings behavior, and target/release interactions; Added tests for Scala-Java interop with overloaded methods; Added tests for Scala-Java package detection; Added tests for TASTy header unpickler version validation; Added tests for TASTy lambda type parameter symbol sharing; Added tests for Xsource:3 macro refinement and whitebox override behavior; Added tests for ZipArchive and AbstractFile URL handling; Added tests for annotation-driven async functionality; Added tests for assignment rewrite on length properties; Added tests for blackbox macro context usage; Added tests for blackbox macro evidence parameters; Added tests for byname implicits in macros; Added tests for collection generic decorators; Added tests for command-line spec usage demo; Added tests for companion class resolution with package-level type aliases; Added tests for companion definitions in package objects; Added tests for companion object owner initialization; Added tests for compiler code actions and reporter configuration; Added tests for compiler phase assembly constraints; Added tests for equality comparison of case objects; Added tests for experimental definition usage restrictions; Added tests for generic signature handling with mixin forwarders; Added tests for handling nested annotation arguments from Java sources; Added tests for higher-kinded type matching; Added tests for implicit ambiguity resolution with package objects; Added tests for implicit import resolution with conflicting class names; Added tests for infix completion scenarios; Added tests for inline access-level checks; Added tests for inlining in constructors; Added tests for issue 9552; Added tests for lambdalift symbol renaming behavior; Added tests for macro Attachments behavior; Added tests for macro and by-name implicit interactions; Added tests for macro annotation unused parameter warnings; Added tests for macro annotation unused parameter warnings and macro expansion usage detection; Added tests for macro attachment preservation during type checking; Added tests for macro attachment preservation on typed identifiers; Added tests for macro attachment retrieval; Added tests for macro expansion discard behavior; Added tests for macro expansion position repair; Added tests for macro implicit resolution with type bounds; Added tests for macro return type inference deprecation; Added tests for macro string interpolation position handling; Added tests for macro-based knownDirectSubclasses; Added tests for macro-based refinement type resolution; Added tests for macro-based typechecking of custom unapply patterns; Added tests for match desugaring of partial functions; Added tests for missing classpath dependencies in TASTy annotations and types; Added tests for negative macro move scenarios in TASTy; Added tests for nested Java class type references; Added tests for nullary override warnings; Added tests for opaque types; Added tests for package object companion case classes; Added tests for package object companion handling; Added tests for package object inheritance and TypeRef cache invalidation; Added tests for package object value access; Added tests for pattern matching on case companion aliases; Added tests for presentation compiler crash and completion fixes; Added tests for presentation compiler member visibility; Added tests for preserving declaration order during pickle/unpickle; Added tests for primitive NaN comparisons, autoboxing, and shift operations; Added tests for protected method override access boundaries; Added tests for raw type handling in Java and Scala interop; Added tests for raw type handling in Java sources; Added tests for raw type regression under separate compilation; Added tests for root context ambiguity resolution; Added tests for runtime reflection null-safety and thread safety; Added tests for scope completion in classes and objects; Added tests for selections on package objects; Added tests for separate compilation scenario (SI-5031); Added tests for separate compilation with parameter aliasing and overloads; Added tests for stack trace formatting and exception handling; Added tests for static forwarders in case class companion objects; Added tests for sys.env behavior; Added tests for testkit assertion and reflection utilities; Added

tests for trait mixin forwarder bytecode generation; Added tests for type pickling of higher-kinded types with abstract type members; Added tests for unpickling local sealed children; Added tests for unpickling of local dummy symbols; Added tests for unused macro warnings; Added tests for value class separate compilation crasher; Added tests for whitebox extractor macros; Added tests for whitebox macro context usage; Added unit tests for ControlThrowable and Exception utilities; Added unit tests for Scala reflection features; Added unit tests for TreeBrowsers; Added unit tests for the Scala compiler classpath implementation; Expanded TASTy run-time test coverage for Scala 3 interoperability; Expanded TASTy test coverage for Scala 3 features; Expanded test coverage for Scala specialization; Instrumented runtime libraries for boxing and array operation counting; JUnit test suite for mutable collections; New JMH benchmark suite for Scala collections; New JUnit test suite for the Scala compiler (nsc); New core test infrastructure for presentation compiler tests; New stylesheets for specification documentation layout and typography; New test infrastructure for the interactive compiler.

Dependencies

Add Ruby dependencies for spec documentation build

A Gemfile has been added to specify the Ruby dependencies required to build the project specification documentation on Travis CI. The file explicitly pins Jekyll to version 3.9.3, Redcarpet to 3.6.0, and includes Rouge and the kramdown-parser-gem gem to support the documentation generation process.

(dependencies) · high confidence

Housekeeping

A new decoder.properties file has been added to the src/scalap directory, establishing the library's version as 2.0.1 and setting the copyright period to 2002-2026 for LAMP/EPFL.

src/scalap · 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 60 → 61 (+1.5)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.

Lenses

  • Code Health 60 → 60 (+0.0)
  • Architecture 87 → 98 (+10.6)
  • Maturity 61 → 64 (+3.9)
  • Readiness 59 → 62 (+3.4)
  • Security 82 → 81 (-1.5)
  • Accessibility 56 → 56 (+0.5)
  • Performance 81 → 91 (+10.7)

Resolved (45)

  • DependencyTraverser.traverse (cognitive 20) (src/sbt-bridge/scala/tools/xsbt/Dependency.scala)
  • DependencyTraverser.traverse (cyclomatic 21) (src/sbt-bridge/scala/tools/xsbt/Dependency.scala)
  • Duplicated block (3–8 lines × 3) (src/library/scala/jdk/DoubleAccumulator.scala)
  • Duplicated block (5 lines × 3) (src/library/scala/jdk/DoubleAccumulator.scala)
  • JavaParser.varDecl (cognitive 27) (src/compiler/scala/tools/nsc/javac/JavaParsers.scala)
  • JavaScanner.getFraction (cognitive 22) (src/compiler/scala/tools/nsc/javac/JavaScanners.scala)
  • JavaScanner.getFraction (cyclomatic 17) (src/compiler/scala/tools/nsc/javac/JavaScanners.scala)
  • Low cohesion: BackendUtils (LCOM4 8) (src/compiler/scala/tools/nsc/backend/jvm/analysis/BackendUtils.scala)
  • Members sharing a duplicated core (4 members, 50+ identical tokens) (src/compiler/scala/tools/nsc/ast/parser/Scanners.scala)
  • Off-boarding risk: anonymized user #1
  • Off-boarding risk: anonymized user #2
  • Off-boarding risk: anonymized user #3
  • Orphaned file (src/compiler/scala/reflect/macros/compiler/Validators.scala)
  • Orphaned file (src/compiler/scala/reflect/reify/codegen/GenTrees.scala)
  • Orphaned file (src/compiler/scala/tools/nsc/transform/patmat/PatternExpansion.scala)
  • Orphaned file (src/compiler/scala/tools/nsc/typechecker/StdAttachments.scala)
  • Orphaned file (src/library/scala/collection/SeqView.scala)
  • Orphaned file (src/library/scala/collection/StrictOptimizedSeqOps.scala)
  • Orphaned file (src/library/scala/collection/StringParsers.scala)
  • Orphaned file (src/library/scala/collection/immutable/TreeMap.scala)
  • …and 25 more

New (130)

  • ClassTooLong: GlbLubs (src/reflect/scala/reflect/internal/tpe/GlbLubs.scala)
  • ClassTooLong: ReificationSupport (src/reflect/scala/reflect/internal/ReificationSupport.scala)
  • DependencyTraverser.traverseTree (cognitive 20) (src/sbt-bridge/scala/tools/xsbt/Dependency.scala)
  • DependencyTraverser.traverseTree (cyclomatic 21) (src/sbt-bridge/scala/tools/xsbt/Dependency.scala)
  • Duplicated block (7 lines × 2) (src/sbt-bridge/scala/tools/xsbt/Dependency.scala)
  • Edited copy of a member (10 corresponding lines) (src/library/scala/collection/mutable/HashMap.scala)
  • Edited copy of a member (10 corresponding lines) (src/library/scala/collection/mutable/RedBlackTree.scala)
  • Edited copy of a member (10 corresponding lines) (src/partest/scala/tools/partest/async/CompletableFutureAwait.scala)
  • Edited copy of a member (10 corresponding lines) (src/reflect/scala/reflect/internal/pickling/UnPickler.scala)
  • Edited copy of a member (11 corresponding lines) (src/library/scala/runtime/Tuple3Zipped.scala)
  • Edited copy of a member (11 corresponding lines) (src/reflect/scala/reflect/internal/util/HashSet.scala)
  • Edited copy of a member (13 corresponding lines) (src/library/scala/collection/ArrayOps.scala)
  • Edited copy of a member (13 corresponding lines) (src/library/scala/collection/immutable/Range.scala)
  • Edited copy of a member (13 corresponding lines) (src/library/scala/runtime/BoxesRunTime.java)
  • Edited copy of a member (14 corresponding lines) (src/compiler/scala/reflect/reify/utils/Extractors.scala)
  • Edited copy of a member (14 corresponding lines) (src/sbt-bridge/scala/tools/xsbt/Dependency.scala)
  • Edited copy of a member (15 corresponding lines) (src/library/scala/collection/immutable/RedBlackTree.scala)
  • Edited copy of a member (17 corresponding lines) (src/library/scala/collection/StringOps.scala)
  • Edited copy of a member (19 corresponding lines) (src/library/scala/collection/LazyZipOps.scala)
  • Edited copy of a member (20 corresponding lines) (src/library/scala/collection/immutable/HashMap.scala)
  • …and 110 more

Changes since last survey

  • 130 commits — 123 feature/other, 7 fixes

By area

  • (repo) — 50 commits
  • src/compiler — 22 commits
  • src/reflect — 22 commits
  • (root) — 10 commits
  • test/files — 10 commits
  • src/library — 5 commits
  • test/junit — 4 commits
  • doc/internal — 2 commits
  • .github/workflows — 1 commit
  • project/MimaFilters.scala — 1 commit
  • src/sbt-bridge — 1 commit
  • src/scaladoc — 1 commit
  • test/async — 1 commit

Notable commits

  • fix: Fix NPE for super[J] on a Java default method under -Ystop-after
  • fix: Fix annotations missed by the unused check
  • fix: Fix immutable Map builder lookup after clear()
  • fix: Fix inverted isEmpty on LazyZip2's filtered view
  • fix: Fix missing fruitless type test warnings
  • fix: Merge pull request #11335 from lrytz/fix-generic-type-boundary-test
  • fix: Merge pull request #11373 from lrytz/fix-13204-unsupported-classfile
  • change: Add a TreeMap's entries, not its keys, in TreeSet's builder
  • change: Analyze a method's producers and consumers only when asked about them
  • change: Annotate the type of a local in SeqView.Sorted
  • change: Avoid megamorphic interface calls to the analyzer
  • change: Avoid per-tree allocations when checking unused types
  • change: Build Duration's unit tables without a regex
  • change: Build ProdConsAnalyzer's consumer map in place
  • change: Bump ruby/setup-ruby from 1.329.0 to 1.334.0
  • change: Call AnnotationCheckers' internal entry points through the component
  • change: Call CapturedVariables through SymbolTable.capturedVariables
  • change: Call ExistentialsAndSkolems through SymbolTable.existentialsAndSkolems
  • change: Call PrivateWithin through SymbolTable.packageAccessBoundaries
  • change: Call Translations through SymbolTable.translations
  • …and 110 more

Architecture

  • Unchanged — 0 containers · 1 contexts · 0 edges

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

Survey your own repository

scala/scala 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 11 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 762d80f17ebc0d0511cd2346bf92ac6874e59158 — the exact code this score is about.
  • Scored under rubric-2026.11.2 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.29+preprod-106b68c3c303.