scala/scala

This system is the Scala compiler and its associated standard library and tooling, responsible for compiling Scala source code into JVM bytecode and providing the core language features. It encompasses the full compilation pipeline, including parsing, type checking, macro expansion, and bytecode generation, alongside utilities for interactive development like the REPL and IDE integration. The codebase also manages the Scala standard library, offering collections, concurrency primitives, and reflection APIs, while providing build and test infrastructure to ensure compiler correctness and performance.

161 changes.

This period was dominated by a comprehensive architectural overhaul of the Scala compiler, introducing modular packages for reflection, macros, and the backend, while simultaneously refactoring the standard library's collection and concurrency APIs. The work also established a robust, automated test suite and improved IDE support through a new presentation compiler infrastructure.

129 changes.

This period focused on the architectural reorganization of the Scaladoc tool, moving its implementation into a dedicated directory and refactoring its components for better maintainability. Concurrently, the codebase introduced blackbox and whitebox macro context APIs, alongside a new GenBCode backend for bytecode generation. The period also saw the addition of extensive test coverage for these new features, as well as improvements to the interactive compiler and REPL.

122 changes.

This period focused on expanding test coverage across the Scala standard library, compiler internals, and the new TASTy reader infrastructure for Scala 3 compatibility. Significant work included implementing the TASTy bridge layer, adding extensive property-based and JUnit tests for collections, and integrating the async/await transformation with corresponding test suites.

55 changes.

This period was dominated by extensive test coverage additions for the Scala compiler, particularly focusing on Java interoperability, TASTy pipeline handling, and macro systems. The work also included integrating the 'splain' module for improved implicit resolution diagnostics and refactoring the sbt-bridge to support richer error reporting.

Added new Scala wrapper classes for Java's reference types, including \PhantomReference\, \SoftReference\, \WeakReference\, \Reference\, and \ReferenceQueue\. These wrappers provide a more idiomatic Scala API, such as returning \Option\[T\]\ from \get()\ instead of \null\, and include extractors for pattern matching.

src/library/scala/ref · high confidence

The partest framework now supports an \instrumented\ test category that profiles method calls in instrumented bytecode. A new \Instrumentation\ object and \Profiler\ Java class are added to the \scala.tools.partest.instrumented\ package, enabling tests to start/stop profiling and retrieve method call statistics, with built-in filtering for \Console\ and \AnsiColor\ classes.

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

The \scala.concurrent.duration\ package is introduced, providing a comprehensive duration handling API. This includes the \Duration\ object for creating and parsing time spans, a \Deadline\ case class for managing expiration times, and a DSL via \DurationConversions\ that allows idiomatic expressions like \3.seconds\ or \3.seconds.fromNow\. The package also exposes \TimeUnit\ constants and implicit conversions to support fluent duration arithmetic and deadline management.

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

The compiler now includes a new ClassPathMemoryConsumptionTester utility for profiling memory usage across different classpath representations, and a CloseableRegistry to manage resource cleanup when the Global instance is closed.

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

The partest-javaagent module now includes a Java agent that instruments bytecode to profile method calls during test runs. The agent registers an ASM-based transformer that intercepts class loading and inserts profiling calls for Scala and empty-package classes, enabling runtime performance measurement of the test suite.

src/partest-javaagent · high confidence

The \spec/public/octicons\ directory now includes the complete Octicons icon set, comprising \octicons.css\ (defining font-face and icon classes), \octicons.svg\ (vector glyphs), and \LICENSE.txt\ (MIT and SIL OFL 1.1 licenses). This adds the full set of GitHub's Octicons to the public assets, enabling their use in the specification's visual representation.

spec/public/octicons · high confidence

The standard library now provides \Stepper\ implementations for a wide range of collection types, enabling more efficient parallel and sequential iteration. New stepper classes have been added for arrays (\ArrayStepper\), binary trees (\BinaryTreeStepper\), bit sets (\BitSetStepper\), Champ-based hash maps and sets (\ChampStepper\), indexed sequences (\IndexedSeqStepper\), iterators (\IteratorStepper\), numeric ranges (\NumericRangeStepper\), integer ranges (\RangeStepper\), strings (\StringStepper\), tables (\TableStepper\), and vectors (\VectorStepper\). These implementations support efficient splitting for parallel processing and expose the \stepper\ method on the respective collection types.

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

The standard library now includes a comprehensive set of abstract function classes (AbstractFunction0 through AbstractFunction22) in the scala.runtime package, providing a consistent base for function implementations. Additionally, new runtime support classes have been introduced, including ArrayCharSequence for efficient character sequence handling, specialized reference wrappers (BooleanRef, ByteRef, CharRef, DoubleRef, FloatRef, IntRef, LongRef) for generic programming, and LazyRef classes to support lazy val initialization. The update also brings in LambdaDeserialize and LambdaDeserializer to handle Java 8+ lambda deserialization via MethodHandles, and adds ClassValueCompat for compatibility with older Java versions. These changes enhance the runtime's capability to handle functional programming constructs and lambda expressions more efficiently.

src/library/scala/runtime · high confidence

Added new \Async\ and \AsyncStateMachine\ classes in the \scala.tools.testkit.async\ package to provide a macro-based \async\/\await\ construct for writing asynchronous tests. This introduces a state-machine-based approach to handling \Future\-based code in tests, allowing developers to write asynchronous test code that appears synchronous.

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

Added new files in src/library-aux for the Scala core type hierarchy, including Any, AnyRef, Nothing, Null, and Singleton. These files provide documentation and stub implementations for the base types, supporting bootstrapping and documentation purposes.

src/library-aux · high confidence

The Scala compiler now generates man pages and HTML documentation from a shared documentation utility. New files in src/manual/scala/tools/docutil implement the logic to parse compiler documentation and emit formatted output: EmitManPage.scala generates standard Unix man pages, while EmitHtml.scala produces HTML versions. ManMaker.scala orchestrates the build process to generate both formats, and ManPage.scala defines the underlying data structures for sections, paragraphs, and text elements. A corresponding CSS file styles the generated HTML.

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

The Scala standard library now includes a comprehensive set of specialized function interfaces in the \scala.runtime.java8\ package, covering \JFunction0\ through \JFunction2\ with primitive parameter and return types (such as \Byte\, \Char\, \Double\, \Float\, \Int\, \Long\, \Short\, \Boolean\, and \Unit\). These interfaces, which extend \Function0\, \Function1\, and \Function2\ with \Serializable\, provide optimized, non-boxing implementations for Java 8 lambda compatibility, ensuring that primitive operations are handled efficiently without unnecessary object allocation.

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

The \spec/\ directory now contains the complete Scala Language Specification, organized into chapters covering lexical syntax, identifiers, types, declarations, classes, expressions, implicits, pattern matching, and top-level definitions. These Markdown files define the formal grammar, typing rules, and evaluation semantics for the language, serving as the authoritative reference for developers and tooling.

spec · high confidence

The admin/init.sh script has been added to automate the setup of sensitive credentials and GPG keys for release processes. It decrypts the private repository credentials and imports the GPG key using the provided passphrase, then copies the GPG configuration to the SBT plugins directory, ensuring the environment is correctly configured for building and signing releases.

admin · high confidence

The \scala.sys.process\ package has been reorganized into separate source files for better maintainability. \ProcessBuilder\, \Process\, \ProcessIO\, \ProcessLogger\, \BasicIO\, \Parser\, and \ProcessImpl\ are now distinct files. This change also introduces a command-line parser (\Parser\) to handle shell-style quoting and escaping, and adds a \daemonized()\ method to \ProcessBuilder\ to allow spawned processes to run as daemon threads, enabling the JVM to exit normally while background processes continue.

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

Added new files Framework.scala and SBTRunner.scala to integrate the Scala partest test suite with sbt's testing interface. This allows partest tests to be discovered and executed within the sbt build environment, with support for colorized logging and proper propagation of test results and exceptions to the sbt test listener.

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

The compiler now includes the 'splain' module in the typechecker, introducing new source files (SplainData, SplainDiagnostics, SplainErrors, SplainFormatData, SplainFormatting) that track implicit search states and format type differences. This enables the \-Vimplicits\ flag to display a complete implicit search tree in error messages, and the \-VtypeDiffs\ flag to show formatted diffs between expected and found types, providing deeper insight into why implicit resolution failed.

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

The Scala compiler now includes a new bytecode generation backend named GenBCode, located in the \src/compiler/scala/tools/nsc/backend/jvm\ directory. This change introduces several new source files, including \AsmUtils.scala\ for debugging and inspection of generated bytecode, and core implementation files such as \BCodeBodyBuilder.scala\, \BCodeHelpers.scala\, \BCodeIdiomatic.scala\, \BCodeSkelBuilder.scala\, \BCodeSyncAndTry.scala\, and \BTypes.scala\. These files implement the logic for constructing ASM \ClassNode\ and \MethodNode\ structures, handling control flow for synchronization and try-catch blocks, and managing type representations (BTypes) for the JVM backend.

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

The compiler now uses a dedicated PathResolver object to handle classpath resolution, environment variable inspection, and default path calculations, replacing previous ad-hoc logic. Additionally, a SystemExit utility is introduced to manage process termination in a way that avoids direct calls to System.exit, improving testability and error handling.

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

Added a new \Properties\ object in \src/partest/scala/tools/partest/utils/Properties.scala\ that loads \scala-partest.properties\ from the JAR. This utility provides a centralized way to access partest configuration properties, including a check for the Avian virtual machine.

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

The Scaladoc tooling now includes a dedicated model for generating class diagrams. This change introduces the \Diagram\ hierarchy (\ContentDiagram\, \InheritanceDiagram\, \Node\ types) and a \DiagramDirectiveParser\ that interprets \@inheritanceDiagram\ and \@contentDiagram\ annotations to control which classes, superclasses, subclasses, and implicit conversions are displayed. The \DiagramFactory\ trait provides the logic to construct these diagrams from template entities, allowing users to visualize class hierarchies and package contents in the generated documentation.

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

The compiler now includes a new \scala.tools.nsc.tasty.bridge\ package that provides the foundational abstractions for reading Scala 3 TASTy files. This layer introduces \TastyUniverse\ and associated operations (\AnnotationOps\, \ContextOps\, \FlagOps\, \NameOps\, \SymbolOps\, \TreeOps\, \TypeOps\) to map TASTy structures to the Scala 2 compiler's internal representation. This enables the compiler to process and understand Scala 3 compiled code, supporting features like annotations, flags, and type representations within the TASTy format.

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

The \scala.sys\ package now provides a typed, type-safe API for accessing and modifying system properties and environment variables. Users can read and write system properties using the new \Prop\ and \BooleanProp\ abstractions, which offer methods like \enable()\, \disable()\, and \toggle()\ for boolean properties. The \SystemProperties\ class wraps Java's \System.getProperties()\ as a mutable map, and the \env\ map now falls back to case-insensitive lookups on platforms that require it.

src/library/scala/sys · high confidence

Added three new files to the partest framework to support testing asynchronous code: CompletableFutureAwait, OptionDsl, and OutputAwait. These files provide macros and state machine implementations that allow tests to write asynchronous code in a synchronous style, enabling easier testing of async operations.

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

A new \Context\ trait is added to \scala.reflect.macros.blackbox\, providing the interface for blackbox macro implementations. This trait exposes the compile-time \universe\, \mirror\, and \prefix\ (including its type), along with a suite of facilities for typechecking, symbol table exploration, tree evaluation, and logging. This establishes the foundation for blackbox macros, which enforce faithfulness to return types, distinguishing them from whitebox macros.

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

The macro compiler now supports macro bundles, a new way to define macro implementations as classes rather than static objects. This change introduces four new files in the macro compiler: DefaultMacroCompiler, which resolves macro implementation references; Errors, which provides specific error messages for macro bundles (e.g., requiring them to be static, non-overloaded, and having a specific constructor shape); Resolvers, which handles the resolution of macro references; and Validators, which enforces that macro implementations match the macro definition's signature. This allows users to define macros using a class-based approach, distinct from the existing object-based macro implementation style.

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

The \src/reflect/scala/reflect/internal/pickling\ directory now contains a complete, new implementation for serializing and deserializing Scala reflection metadata. This includes \ByteCodecs\ for handling byte array encoding, \PickleBuffer\ for variable-length byte array management, \PickleFormat\ defining the serialization schema, \Translations\ for mapping Scala types to pickle tags, and \UnPickler\ for reading the serialized data. This replaces the previous, likely less efficient or more complex, serialization mechanism with a structured, tag-based format.

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

The \src/partest/scala/tools/partest/nest\ directory now contains a new, modular test runner architecture for the Scala test suite (partest). This includes a command-line parsing DSL (\CommandLine\, \Opt\, \Spec\), a new runner interface (\AbstractRunner\, \Runner\), and supporting utilities (\FileManager\, \PathSettings\, \DirectCompiler\). This change replaces the previous monolithic test runner with a more flexible, composable structure that supports features like grep-based filtering, verbose/terse output modes, and better handling of compiler and Java options.

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

Added new files (JavaTokens, JavaScanners, JavaParsers) that provide the tokenizer and parser for Java source files, enabling the Scala compiler to parse Java code directly.

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

Added a new \fsc\ (fast Scala compiler) implementation in the \src/compiler/scala/tools/nsc/fsc\ directory. This introduces a client-server architecture where the \CompileClient\ sends compilation requests to a persistent \CompileServer\ daemon, which caches compiler instances to speed up subsequent builds. The change includes new files for socket communication (\CompileSocket\, \Socket\), server management (\SocketServer\, \CompileServer\), and settings (\FscSettings\), enabling users to benefit from faster compilation times through a background process.

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

Added the \Awaitable\ trait and \Await\ object to provide a standardized way to block-wait for asynchronous results, replacing the previous ad-hoc blocking mechanisms. Introduced \BlockContext\ to allow thread pools to optimize behavior when threads are about to block. Added \BatchingExecutor\ to optimize nested task execution on the same thread, improving performance for short-lived tasks. The \Future\ and \Promise\ APIs were significantly refactored, including the addition of \transform\, \transformWith\, \zipWith\, and other combinators, while deprecating older synchronization primitives like \SyncVar\, \SyncChannel\, and \DelayedLazyVal\ in favor of standard Java concurrency utilities.

src/library/scala/concurrent · high confidence

Added new files to the Scala compiler's quasiquotes module: Holes.scala, Parsers.scala, Placeholders.scala, Quasiquotes.scala, and Reifiers.scala. These files implement the core logic for parsing and reifying Scala code containing unquote placeholders, enabling the compiler to process quasiquote syntax.

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

The standard library now includes new immutable collection types: ArraySeq, a memory-efficient immutable array supporting fast indexed access, and BitSet, an immutable set of non-negative integers. These additions expand the available immutable collection types in the scala.collection.immutable package, providing users with optimized data structures for specific use cases such as dense integer sets and fixed-size arrays.

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

A new \scala.util.hashing\ package is added, introducing a \Hashing\[T\]\ trait for custom hashing strategies and a \MurmurHash3\ implementation for computing hash codes. The package also provides \ByteswapHashing\ for fast multiplicative hashing and utility functions like \byteswap32\/\byteswap64\. This provides a structured way to define and use custom hashers in the standard library.

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

The Scala compiler's reification subsystem now includes a new \scala.reflect.reify.utils\ package containing helper classes for the reifier. \Extractors\ provides pattern matching for reified trees and types, \NodePrinters\ handles the human-readable printing of reified code, \StdAttachments\ defines attachment types for reification bindings and aliases, and \SymbolTables\ manages the mapping between symbols and their reified representations. These utilities support the internal mechanics of the reifier, enabling more robust handling of free symbols, renamed imports, and path-dependent types.

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

The \scala.util.matching.Regex\ class is introduced to provide regular expression matching against strings, allowing users to extract information from matches or replace them. This new API supports pattern matching with extractors, finding and replacing text, and iterating over matches, delegating to Java's \java.util.regex\ package.

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

A new \scala.reflect.macros.whitebox.Context\ trait has been added to the Scala reflection API. This trait extends the existing \blackbox.Context\ and introduces methods to inspect the state of macro expansion, including \openMacros\, \enclosingMacros\, \openImplicits\, and \enclosingImplicits\. This enables macro writers to access internal compiler functionality and refine the type of macro expansions beyond their official return types, offering more powerful capabilities compared to blackbox macros.

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

The repository introduces a suite of new shell scripts to automate the build, testing, and release processes. The \scripts/bootstrap\_fun\ and \scripts/common\ files implement the core build logic, handling version determination, bootstrapping the Scala compiler, and managing repository resolvers for both integration and release builds. A new \scripts/stability-test.sh\ script is added to verify build stability by comparing class files between builds. Additionally, \scripts/generate-spec-pdf.sh\ and \scripts/generate-spec-pdf.bat\ automate the generation of specification PDFs from HTML sources, while \scripts/travis-publish-spec.sh\ handles secure publishing of these specs. These changes streamline the CI/CD pipeline by centralizing build and release logic in dedicated scripts.

scripts · high confidence

Added new shell scripts at scripts/jobs/validate/publish-core and scripts/jobs/validate/test to handle CI validation workflows. The publish-core script manages publishing the core Scala artifacts to Maven, including version parsing, availability checks, and artifact generation. The test script executes the full test suite (JUnit, ScalaCheck, partest, OSGi, MiMa, and Scaladoc) using sbt. These scripts integrate with the existing CI infrastructure to automate core publishing and comprehensive testing.

scripts/jobs/validate · medium confidence

Added new abstract Generator class and Universer trait to the Scaladoc doclet package. The Generator class provides a base for custom documentation generators, including a checks mechanism to ensure preconditions are met before generation. The Universer trait allows generators to access a Universe data structure representing the documented program's interfaces and comments.

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

The manual pages for the Scala toolchain have been restructured into a new Scala-based documentation system. This change introduces formal man pages for the \fsc\ (offline compiler), \scala\ (script runner/REPL), \scalac\ (compiler), \scaladoc\ (documentation generator), and \scalap\ (class file decoder). Each tool's documentation now includes detailed sections on command-line options, environment variables (such as \JAVACMD\ and \JAVA\_OPTS\), and usage examples, providing a consistent and comprehensive reference for users interacting with the Scala development environment.

src/manual/scala/man1 · high confidence

The \src/tastytest\ directory now contains a complete, standalone test runner for validating TASTy (Scala 3) and Scala 2/3 interop. This new infrastructure introduces a modular command-line interface with subcommands for compiling and running Scala 2 (\Scalac\), Scala 3 (\Dotc\), Java (\Javac\), and documentation (\Scaladoc\) code, alongside utilities for file handling (\Files\, \ClasspathOps\), diffing (\Diff\), and test suite execution (\TastyTest\). The runner supports multiple test suite types (positive, negative, pipelined, and full-circle) to verify compilation and behavior across different compiler configurations.

src/tastytest · high confidence

The \scala.io\ package now includes \AnsiColor\ for terminal text styling and color, a new \BufferedSource\ class for efficient line and character iteration, and a refactored \Codec\ class that replaces the previous \charsets\-based approach with a \Charset\-backed implementation. \Source\ has been updated to use \BufferedSource\ for file and stream operations, and \StdIn\ provides typed reading methods for console input.

src/library/scala/io · high confidence

The \scala.annotation\ package introduces a new \Annotation\ base class and a \StaticAnnotation\ trait, providing a structured hierarchy for compiler and reflection tools. Several new annotations are added to the standard library, including \@elidable\ for excluding method bodies from bytecode, \@tailrec\ to enforce tail-call optimization, \@switch\ to verify switch compilation, \@implicitNotFound\ and \@implicitAmbiguous\ for customizing implicit resolution errors, \@nowarn\ for local warning suppression, \@migration\ for documenting behavioral changes, and \@varargs\ for Java interop. Additionally, \@unused\ is introduced to suppress unused warnings, and \@strictfp\ is added to control the strict floating-point flag.

src/library/scala/annotation · high confidence

The backend now includes a new analysis framework in the \analysis\ package, introducing \AliasingAnalyzer\, \NullnessAnalyzer\, \ProdConsAnalyzer\, and \TypeFlowAnalyzer\. These components enable the compiler to track nullness states and variable aliasing during bytecode generation, allowing for more aggressive optimizations such as dead code elimination and inlining improvements. The \BackendUtils\ component provides utility functions for computing max locals/stack and managing lambda deserialization methods.

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

A new executable script at scripts/jobs/integrate/bootstrap has been added to handle the bootstrapping process for integration builds. This script sources common utilities and defines a workflow that generates repository configurations, determines the Scala version, removes existing builds, and sequentially executes build and test steps including starr, locker, quick builds, and stability tests.

scripts/jobs/integrate · high confidence

The \scala.collection.generic\ package introduces several new type classes (\IsIterable\, \IsIterableOnce\, \IsMap\, \IsSeq\) that enable extension methods to work uniformly on standard collections and other types like \String\ or \Range\. It also adds \DefaultSerializationProxy\ and \DefaultSerializable\ to provide a consistent, opt-in serialization mechanism for collections, replacing the previous default behavior. Additionally, \BitOperations\ and \CommonErrors\ are added to support collection internals, while deprecated aliases for older type classes are provided for backward compatibility.

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

The compiler now includes a new profiling subsystem in \src/compiler/scala/tools/nsc/profile\ that enables detailed performance measurement. This adds support for per-phase profiling metrics including wall clock time, idle time, CPU time, user time, allocated memory, retained heap, and GC time. It also introduces an external tool hook for integration with profilers like YourKit or JProfiler, and provides a thread pool factory that instruments background threads to capture benchmarking data, serving as an enabler for future optimizations such as multi-threaded post-processing and class writing for GenBCode.

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

Added new classes and objects to \scala.util.control\ to provide structured control flow and exception handling. \Breaks\ introduces a \break\ control abstraction for loops, allowing early exit from \breakable\ blocks. \ControlThrowable\ is a new base class for throwables used for flow control, with stack trace suppression enabled by default. \NoStackTrace\ provides a trait for exceptions that do not fill in stack traces for efficiency. \NonFatal\ is a new extractor and object to match only non-fatal throwables, excluding fatal errors like \VirtualMachineError\ and \ControlThrowable\. \Exception\ provides a DSL for composing exception handlers with methods like \opt\, \either\, and \withTry\. \TailCalls\ implements tail-call optimization via trampolining, allowing deep recursion without stack overflow.

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

Added several new shell scripts in the tools directory to assist with development workflows: abspath for resolving absolute paths, class-dump for inspecting Java class signatures, cleanup-commit for pre-commit whitespace and tab cleanup, compare-java-sigs for comparing Java signatures between builds, cpof for constructing classpaths, jar-dump for listing JAR contents, pathResolver for resolving Scala paths, rm-orphan-checkfiles for cleaning up test artifacts, scaladoc-compare and scaladoc-diff for comparing Scaladoc outputs, and verify-jar-cache for validating cached JARs. Removed the legacy binary-repo-lib.sh script and its associated SHA1 file.

tools · high confidence

The \scala.collection.convert\ package now provides new, non-implicit conversion mechanisms for interoperability with Java collections. \AsJavaConverters\ and \AsScalaConverters\ offer explicit conversion methods, while \AsJavaExtensions\ and \AsScalaExtensions\ provide corresponding extension methods (e.g., \asJava\, \asScala\) available via \scala.jdk.CollectionConverters\. Additionally, \StreamExtensions\ adds \asJavaSeqStream\ and \asJavaParStream\ methods to convert Scala collections, maps, and arrays into Java 8+ \Stream\ objects. These new APIs replace the previously implicit-based \JavaConverters\ and \ImplicitConversions\, which are now deprecated.

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

The compiler's \scala.tools.nsc.io\ package now exposes \SourceReader\ for decoding source files and \Jar\/\JarWriter\ for creating JAR archives. Users can read source files via the new \SourceReader\ class, which handles charset decoding and interrupt handling, and can create JAR files using the \Jar.create\ method or the \JarWriter\ API, which supports adding files and directories to a JAR with a specified manifest.

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

Added several new internal utility classes to \scala.reflect.internal.util\, including \AbstractFileClassLoader\ for loading classes from \AbstractFile\ sources, \ChromeTrace\ for generating Chrome tracing data, \CodeAction\ and \TextEdit\ for communicating code edit suggestions to tooling, \Collections\ with optimized list operations, \FileUtils\ for asynchronous file writing, \FreshNameCreator\ for generating unique names, \HashSet\ for efficient set operations, \JavaClearable\ for managing weak references to Java collections, \Origins\ for debugging call stacks, \OwnerOnlyChmod\ for secure file permission setting, \Position\ for source code location tracking, \ReusableInstance\ for caching instances, and \ScalaClassLoader\ for class loading. These additions support the \scala-reflect\ jar and improve compiler performance and tooling integration.

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

Added new utility classes in the macro reflection package to support macro debugging and type-level transformations. The \Traces\ trait introduces \macroDebugLite\ and \macroDebugVerbose\ flags to control logging of macro expansion details, enabling developers to trace macro behavior during compilation. The \Helpers\ trait provides methods for transforming macro implementation signatures, specifically handling \WeakTypeTag\ evidence parameters, and for adjusting metalevels by converting between \c.Expr\[T\]\ and \c.Tree\ types, simplifying signature analysis and macro argument creation.

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

The compiler now uses a dedicated macro runtime system to resolve and invoke macro implementations. This includes a new \AbortMacroException\ for handling missing macro implementations, a \MacroRuntimes\ trait that manages macro classloaders and caches runtime instances, and a \JavaReflectionRuntimes\ trait that handles the actual invocation of macro code via Java reflection. This change separates the macro execution logic from the main compiler, allowing for better resource management and isolation of macro implementations.

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

The \scala.annotation.meta\ package now includes new meta-annotation classes (\beanGetter\, \beanSetter\, \companionClass\, \companionMethod\, \companionObject\, \defaultArg\, \field\, \getter\, \languageFeature\, \param\, \setter\, \superArg\, \superFwdArg\). These annotations allow developers to control where annotations are applied, such as directing an annotation to a class's getter, setter, or companion object, rather than just the primary declaration.

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

The compiler plugin system has been refactored into a new set of classes (Plugin, PluginComponent, PluginDescription) that support caching of plugin classloaders to improve startup performance. The \Plugins\ trait now exposes \findPluginClassLoader\ to allow build tools to customize classloader creation, and provides \writeAdditionalOutputs\ and \augmentManifest\ hooks for plugins to modify build artifacts.

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

The \scalax.rules\ package introduces a new combinator-based parsing framework for the Scala signature parser. This adds core types including \Rule\, \Result\ (with \Success\, \Failure\, and \Error\ states), and \Rules\ factory traits that enable declarative parsing logic. The implementation includes memoization support via \Memoisable\ and \DefaultMemoisable\ to cache rule results, and \SeqRule\ to handle sequence operations like repetition (\\*\, \+\) and optional matching (\?\). This refactors the underlying parsing mechanism, allowing for more modular and composable parsing rules within the scalap tool.

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

The project has migrated from the legacy Ant-based build system to a comprehensive sbt build infrastructure. This change introduces a suite of sbt plugins and build-time code generators that automate the creation of Scala source files, including function converters, \AnyVal\ representations, compiler settings documentation, and OSGi manifest headers. The build also integrates tools for analyzing JMH benchmarks via JitWatch and enforces binary compatibility checks using MiMa.

project · high confidence

The \scala.jdk\ package has been introduced to provide new conversion utilities and data structures for interoperating with Java. This includes \Accumulator\ classes (\IntAccumulator\, \LongAccumulator\, \DoubleAccumulator\, \AnyAccumulator\) for efficient parallel collection building, as well as converter objects for \Collection\, \Future\, \Function\, \Duration\, and \Stream\ types. These replace or supplement the older \scala.collection.convert\ and \java8-compat\ mechanisms, offering explicit extension methods like \asJava\ and \asScala\ for seamless bridging between Scala and Java APIs.

src/library/scala/jdk · high confidence

The reflection and compiler internal settings are now managed through a new \AbsSettings\ trait and \MutableSettings\ class, introducing a typed, value-based settings model that avoids the previous boxing overhead for boolean flags. This change provides a more efficient and type-safe way to access and modify compiler and reflection settings, with deprecated implicit conversions for backward compatibility.

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

The compiler now includes new classes for browsing and tracking symbols, specifically \BrowsingLoaders\ and \SymbolTrackers\. \BrowsingLoaders\ enables the compiler to parse source files and enter top-level classes and modules into the symbol table without fully resolving them, which is essential for IDE features like code completion and navigation. \SymbolTrackers\ provides a mechanism to monitor changes in the symbol graph (additions, removals, owner changes, and flag changes) during compilation phases, likely to support IDE diagnostics and incremental compilation. These changes enhance the compiler's ability to support interactive development environments.

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

The partest suite gains a suite of new test base classes that enable more granular testing of the Scala compiler and REPL. Developers can now write tests that inspect generated bytecode via the ASM library (BytecodeTest), verify internal compiler structures and types (CompilerTest), validate intermediate code (IcodeTest, IcodeComparison), and test REPL interactions with robust output normalization (ReplTest, SessionTest). Additional helpers include JUnitTest for JUnit integration, JavapTest for JVM bytecode verification, MemoryTest for leak detection, and ScaladocModelTest for documentation generation. These changes provide a more structured and powerful framework for validating compiler behavior and REPL functionality.

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

The testkit module now includes new utilities to support internal testing: ASMConverters for inspecting bytecode via the ASM library, an AllocationTest trait to verify memory allocation behavior, AssertUtil with improved exception-checking assertions, BytecodeTesting for compiling and inspecting classes in memory, ReflectUtil for safe reflection access, and helpers for managing temporary directories and resources. These additions provide a more robust foundation for writing and maintaining compiler and library tests.

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

The Scala standard library now includes three new annotations in the \scala.annotation.unchecked\ package: \@uncheckedOverride\ allows definitions to override without enforcing the \override\ keyword; \@uncheckedStable\ marks values as stable despite volatile types; and \@uncheckedVariance\ suppresses variance checking for type arguments.

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

The scala.util package now includes several new types and features: ChainingOps provides tap and pipe methods for every type; DynamicVariable (renamed from Fluid) offers thread-local binding; Try supports withFilter and fold; Using implements the loan pattern for resource management; and Either gains a flatten operation and is right-biased.

src/library/scala/util · high confidence

The compiler now uses a 'fast-track' mechanism to directly expand string interpolators (\s\, \raw\, \f\) and related reflection features (like \reify\ and quasiquotes) at compile time, bypassing the standard reflective load and invoke overhead. This change introduces new internal classes in \scala.tools.reflect\ (such as \FastStringInterpolator\ and \FastTrack\) to handle these expansions, resulting in faster compilation and execution for code using string interpolation.

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

The REPL frontend has been split into distinct, single-responsibility components within the \scala.tools.nsc.interpreter.shell\ package. This refactoring introduces new classes such as \ILoop\ for the main interactive loop, \ReplCompletion\ for code completion, \Pasted\ for handling transcript pastes, \LoopCommands\ for shell commands, and \ReplReporterImpl\ for output formatting. These changes decouple the user interface layer from the compiler, allowing the REPL to potentially run over a remote connection or with different input/output implementations.

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

The \scala.reflect.api\ package has been reorganized into a set of new traits (e.g., \Annotations\, \Constants\, \Exprs\, \FlagSets\, \ImplicitTags\, \Internals\, \JavaUniverse\, \Liftables\, \Mirror\, \Mirrors\) that define the public reflection API. This change introduces new types such as \Expr\, \Constant\, and \Annotation\ with associated extractors and API traits, while also exposing internal implementation details via the \internal\ module. The refactoring aims to provide a more robust and consistent reflection API, with clear demarcation between public and internal APIs.

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

Added foundational documentation and configuration files to standardize the development workflow. This includes a comprehensive CONTRIBUTING.md guide for new and existing contributors, an AGENTS.md document providing technical guidance for AI agents and developers, and a LLM\_POLICY.md outlining rules for LLM-generated code. Additionally, the repository now includes a .mailmap file to consolidate author identities, a .gitattributes file to enforce consistent line endings across the codebase, and a .scala-steward.conf to manage automated dependency updates. These changes improve the onboarding experience and clarify the project's contribution standards.

(repo-wide) · high confidence

The SCALAP decoder configuration file (decoder.properties) was added, establishing the library version as 2.0.1 and setting the copyright string to cover the period 2002–2026 for LAMP/EPFL.

src/scalap · high confidence

The Scaladoc resource files have been replaced with a new set of assets, introducing a modernized look and feel. This update includes new SVG icons for various Scala types (such as classes, objects, and annotations), updated CSS styles for layout and typography, and new JavaScript files for search and scheduling functionality. These changes collectively refresh the appearance of the generated documentation and enhance the search and navigation experience.

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

The Scaladoc search functionality has been restructured to use a new \IndexScript\ that generates a JavaScript index of all packages and members, enabling client-side search. This change introduces a dedicated \JSON\ helper for serializing the index data and updates the \Entity\ page template to include the search UI and results container, replacing the previous implementation.

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

The \scala.tools.scalap\ package has been restructured from a monolithic implementation into distinct, single-responsibility classes. \Arguments\ now handles command-line parsing, \ByteArrayReader\ manages raw byte stream access, \Classfile\ parses the Java class file header and constant pool, \Classfiles\ defines the relevant constants, \CodeWriter\ and \JavaWriter\ handle output formatting, and \Main\ orchestrates the decoding process. This change improves code maintainability and separation of concerns within the classfile decoder.

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

The \src/compiler/scala/tools/nsc/ast\ directory now contains several new, distinct files that organize previously scattered or monolithic compiler logic. \DocComments.scala\ handles the parsing and inheritance of ScalaDoc comments. \NodePrinters.scala\ and \Printers.scala\ manage the stringification and pretty-printing of Abstract Syntax Trees for debugging and IDE support. \Positions.scala\ centralizes position assignment and validation logic. \TreeBrowsers.scala\ provides the Swing-based GUI for visualizing ASTs. \TreeDSL.scala\ and \TreeGen.scala\ contain the domain-specific language and generation utilities for constructing AST nodes. This refactoring separates concerns, making the compiler's internal tree representation and its associated utilities easier to navigate and maintain.

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

The internal implementation of the Scala compiler's type erasure and uncurrying phases has been refactored. The \Erasure\ and \UnCurry\ logic, previously embedded within the main compiler pipeline, has been extracted into dedicated traits (\Erasure\, \UnCurry\, \PostErasure\) in the \scala.reflect.internal.transform\ package. This change isolates the type transformation logic, making the compiler's internal API more modular and easier to maintain. Users should see no direct change in behavior, but the compiler's internal structure is now cleaner and more organized.

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

The TASTy reader implementation has been refactored into distinct, modular components to improve maintainability and separation of concerns. A new \TastyModes\ class introduces a bitset of modes that control the interpretation of a TASTy file, such as distinguishing between reading class parents, annotation trees, or macro definitions. A \ForceKinds\ class provides a bitset for debugging why a symbol was forced. The \TastyUniverse\ is now a facade that maps TASTy operations to the nsc compiler, while \TastyUnpickler\ and \TreeUnpickler\ handle the actual unpickling logic. This change reorganizes the internal structure of the TASTy reader without altering the external API.

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

The compiler's classfile parsing and symbol pickling logic has been refactored into new, dedicated classes: \AbstractFileReader\, \DataReader\, \ReusableDataReader\, \ClassfileParser\, and \Pickler\. This change introduces a more modular and reusable architecture for reading \.class\ and \.sig\ files, separating the low-level byte-reading concerns from the higher-level parsing and pickling logic. Users benefit from improved maintainability and potential performance gains through buffer reuse and cleaner code structure.

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

The compiler's reporting system has been restructured into a new hierarchy of reporter classes. A new \PrintReporter\ trait handles the actual output formatting and console interaction. \ConsoleReporter\ provides the standard console output, \StoreReporter\ captures reports for programmatic access, \ForwardingReporter\ allows wrapping another reporter, and \NoReporter\ suppresses all output. This change introduces these specific classes and their relationships, replacing the previous, less modular reporting implementation.

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

The compiler's command-line and programmatic settings have been refactored from a mutable, monolithic class into a structured hierarchy of traits and classes. This introduces an immutable \AbsSettings\ interface and a \MutableSettings\ implementation, allowing settings to be copied and reused safely. The change also introduces a \PathFactory\ abstraction for resolving file paths, and a new \ScalaVersion\ type for handling version comparisons. Users will see a more robust and predictable settings system, with better support for embedding the compiler and managing configuration state.

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

The macro context implementation has been refactored from a single large class into a set of smaller, composable traits (e.g., \Aliases\, \Enclosures\, \Evals\, \ExprUtils\, \FrontEnds\, \Infrastructure\, \Internals\, \Names\, \Parsers\, \Reifiers\, \Traces\, \Typers\) that are mixed into the \Context\ class. This change reorganizes the macro engine's capabilities, such as type checking, expression reification, and name generation, into distinct, reusable components, improving code structure and maintainability.

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

The pattern matching translation logic has been refactored into separate, focused files (Logic, MatchAnalysis, MatchCodeGen, MatchCps, MatchOptimization, MatchTranslation, MatchTreeMaking, MatchWarnings). This modularization improves maintainability and allows for more targeted optimizations, such as common sub-expression elimination and optimized code generation for Option-based matching, while preserving the existing pattern matching behavior for users.

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

The internal type system logic has been reorganized by moving and splitting key traits—CommonOwners, FindMembers, GlbLubs, TypeComparers, TypeConstraints, TypeMaps, and TypeToStrings—into the new \scala.reflect.internal.tpe\ package. This change groups related type-handling implementations together, improving code organization and maintainability within the compiler's reflection layer.

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

The Scaladoc HTML generation logic has been reorganized into a new \scala.tools.nsc.doc.html\ package. This refactoring introduces dedicated classes for the document generator (\Doclet\), the HTML factory (\HtmlFactory\), and page templates (\HtmlPage\, \Page\), alongside a lightweight HTML tag DSL (\HtmlTags\) and syntax highlighting (\SyntaxHigh\). This change moves the HTML generation code out of the previous location, improving code structure and maintainability.

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

The Scaladoc implementation has been moved from the main compiler source tree into a dedicated \src/scaladoc\ directory. This change reorganizes the codebase to separate the documentation generation logic from the core compiler, making the project structure clearer and potentially reducing compilation dependencies.

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

The Scaladoc model implementation has been refactored to use a new set of traits and classes in the \scala.tools.nsc.doc.model\ package. This includes new abstractions for entities (classes, traits, objects, methods, etc.), comments, types, and lookups. This change restructures how the documentation generator models Scala code, likely improving modularity and maintainability of the Scaladoc tool.

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

The core Scaladoc comment parsing logic (CommentFactoryBase) and the member lookup/LinkTo resolution (MemberLookupBase, LinkTo) have been moved into the base package. This refactoring isolates the lightweight documentation extraction and link resolution logic, allowing it to be reused by the IDE for fast, shallow documentation lookups without the full compiler context.

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

A new internal annotation, @uncheckedBounds, is introduced in the scala.reflect.internal.annotations package to suppress type parameter bound checks during the refchecks phase, addressing issue SI-7694. Additionally, the internal @compileTimeOnly type is deprecated in favor of the standard library's scala.annotation.compileTimeOnly.

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

A new internal annotation, \macroImpl\, has been added to the Scala library. This annotation links macro definitions with their corresponding implementations, ensuring that macro definitions and their implementations are correctly linked between compilation runs. This change is necessary to preserve the connection between macro definitions and their implementations during the compilation process.

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

The documentation for \scala.beans.BeanProperty\ and \scala.beans.BooleanBeanProperty\ has been updated to clarify that in Scala 3, the generated getter and setter methods are only visible from Java (including via Java reflection), whereas in Scala 2 they were visible from both Scala and Java.

src/library/scala/beans · high confidence

The \AnyRefMap\ class is now deprecated in favor of \HashMap\, and the \MultiMap\ and \ListMap\ mutable collections have been deprecated. These changes reflect a shift towards a more unified and performant collection API, with \AnyRefMap\ specifically noted as being slower than the new \HashMap\ implementation. The deprecation warnings will guide users to migrate to the recommended alternatives.

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

The InteractiveReader object in the REPL frontend has been marked as deprecated and reduced to a no-op stub. This change removes the previous embedded JLine functionality, replacing it with a compatibility layer for sbt's ConsoleInterface, signaling that users should migrate away from this class.

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

The \scala.compat.Platform\ object and its members (including \arraycopy\, \createArray\, \arrayclear\, \getClassForName\, \EOL\, \currentTime\, and \collectGarbage\) are now deprecated as of version 2.13.0. Users should migrate to the corresponding Java standard library equivalents, such as \java.lang.System.arraycopy\, \java.lang.reflect.Array.newInstance\, \java.util.Arrays.fill\, \java.lang.Class.forName\, \java.lang.System.lineSeparator\, \java.lang.System.currentTimeMillis\, \java.lang.System.gc\, and \java.nio.charset.Charset.defaultCharset.name\.

src/library/scala/compat · high confidence

The \ClassManifest\ type alias and \ClassManifest\ object in \scala.reflect\ are now annotated with \@deprecated\ targeting version 2.10.0, directing users to migrate to \ClassTag\ and \TypeTag\ respectively. The \ClassManifestDeprecatedApis\ trait and its methods (such as \erasure\, \\<:\<\, \newArray\, and \newWrappedArray\) are also marked as deprecated, signaling that these legacy reflection constructs are being phased out in favor of the newer type tag system.

src/library/scala/reflect · high confidence

The XML parser implementation in the Scala compiler has been refactored by extracting common parsing logic into new files: \MarkupParserCommon.scala\ and \Utility.scala\. These files contain shared code for parsing XML tags, attributes, character references, and entity unescaping, which was previously duplicated or embedded within the compiler's parser. This change improves code reuse between the library-level and compiler-level XML parsers.

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

The Scala compiler's classpath implementation has been refactored to support a new 'flat' classpath model, which provides a more efficient and simpler way to handle classpath entries, particularly for Java 9+ modular runtime images and JAR files. This change introduces new classes like \AggregateClassPath\, \ClassPathFactory\, and \DirectoryClassPath\ to manage class and source paths more effectively. The flat classpath is enabled by default, improving performance and compatibility with modern Java versions.

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

Added new files Interpreter.scala and MainGenericRunner.scala to the REPL frontend. Interpreter.scala provides deprecated wrapper classes (Interpreter, InterpreterLoop) that bridge the old sbt/console interface to the new IMain/Repl architecture. MainGenericRunner.scala introduces the primary command-line runner (MainGenericRunner) and supporting runners (JarRunner, ScriptRunner) that handle script execution, JAR running, and interactive REPL invocation, replacing the previous single-entry-point logic.

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

The reification logic has been refactored into new phases: \Calculate\ tracks local symbols and their metalevels, \Metalevels\ handles cross-stage bindings and splice validation, and \Reshape\ reverts typechecker modifications like macro expansions. This restructuring allows the compiler to properly handle complex reification scenarios, such as those involving type lambdas and nested splices, by explicitly managing the metalevel of symbols and inlining free variables where appropriate.

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

The runtime reflection subsystem now enforces thread safety through a Global Interpreter Lock (GIL). This change introduces a new \Gil\ trait and \SynchronizedOps\ to synchronize access to symbols, names, and base type sequences, addressing race conditions and memory leaks in multi-threaded environments. The \JavaUniverse\ and \JavaMirrors\ implementations are updated to use this locking mechanism, ensuring that reflective operations like symbol lookup and class completion are safe for concurrent use.

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

The concurrent map implementation in \scala.collection.concurrent\ has been refactored to use new Java classes (\BasicNode\, \CNodeBase\, \Gen\, \INodeBase\, \MainNode\) alongside the existing Scala \TrieMap\ and \Map\ traits. This change introduces a Java-based node structure for the underlying trie data structure, likely to improve performance or interoperability, while maintaining the Scala API surface defined in \Map.scala\.

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

The Scala compiler's JVM backend optimizer has been significantly restructured and expanded. New files introduce dedicated components for managing bytecode repositories (ByteCodeRepository, FifoCache), building call graphs (CallGraph), and performing specific optimizations such as copy propagation (CopyProp), closure rewriting (ClosureOptimizer), and box/unbox elimination (BoxUnbox). The inliner has been integrated into the backend pipeline, with new heuristics for inlining methods, handling lambda methods, and managing inline requests. Utility functions for bytecode analysis (BytecodeUtils) and attribute handling (InlineInfoAttribute) have also been added or refactored to support these changes.

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

The internal implementation of \Future\, \Promise\, and \ExecutionContext\ has been significantly reworked to improve performance, correctness, and Java 8 compatibility. \DefaultPromise\ and \Future\ implementations are rewritten with optimized locking and memory management, including link compression to prevent memory leaks. A new \ExecutionContextImpl\ is introduced to manage thread pools and blocking contexts more effectively. Additionally, \FutureConverters\ are added to bridge Scala \Future\ with Java 8 \CompletionStage\, enabling interoperability with Java 8 concurrency APIs.

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

The presentation compiler and related interactive-mode components (including \CompilerControl\, \ContextTrees\, \Global\, \InteractiveReporter\, \Lexer\, \Main\, \Pickler\, \Picklers\, \PresentationCompilerThread\, \PrettyWriter\, and \REPL\) have been moved from their previous locations into a new \src/interactive\ package. This structural change isolates the interactive compiler implementation, making the codebase easier to navigate and maintain while preserving the existing behavior for IDEs and REPL users.

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

The \CollectionConverters\, \DurationConverters\, \FunctionConverters\, \FutureConverters\, \OptionConverters\, and \StreamConverters\ objects have been moved to the \scala.jdk.javaapi\ package. These objects provide explicit conversion methods intended for use in Java code, while Scala code is recommended to use the extension methods defined in the corresponding \scala.jdk\ packages.

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

The TASTy reader has been refactored into a new set of classes in the \scala.tools.tasty\ package, including \TastyHeaderUnpickler\, \AttributeUnpickler\, \TastyName\, \ErasedTypeRef\, and \Signature\. This change introduces support for reading TASTy files from Scala 3.0.0-M1 through 3.6, with version compatibility checks ensuring that the compiler can only read TASTy files that are backward compatible with the current compiler version. The new implementation provides a more robust and flexible way to parse and interpret TASTy files, which is essential for cross-compilation and tooling that needs to read Scala 3 compiled code.

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

The standard library's collection framework has been significantly refactored to improve performance, reduce memory overhead, and modernize the API. Key changes include the introduction of \IterableOnce\ and \IterableOnceOps\ as base abstractions for iteration, the addition of \knownSize\ for better size hinting, and the introduction of \Stepper\ for parallel processing. The \ArrayOps\ class now provides efficient wrappers for primitive arrays, and various collection operations (such as \fold\, \reduce\, and \sliding\) have been optimized. Additionally, deprecated methods like \JavaConversions\ and \Traversable\ have been removed or replaced with \JavaConverters\ and \Iterable\ respectively, while new methods like \minOption\/\maxOption\ and \unfold\ have been added to iterators and factories.

src/library/scala/collection · high confidence

The REPL implementation has been modularized, splitting the code into distinct files such as \AbstractOrMissingHandler\, \ExprTyper\, \IMain\, \Imports\, \Interface\, \MemberHandlers\, \Naming\, \Phased\, \Power\, and \PresentationCompilation\. This refactoring separates concerns within the REPL, such as expression typing, import handling, and presentation compilation, making the codebase more maintainable and allowing for potential separation of the shell from the compiler logic.

src/repl · high confidence

The Scala REPL's line editor has been migrated from the legacy JLine 2 implementation to JLine 3. This upgrade brings improved tab completion with better handling of non-identifier tokens, enhanced history management, and more accurate word boundaries for the line editor. Users will experience smoother interactive editing, including support for \.inputrc\ configuration files and a new shortcut (Ctrl-Alt-T) to display the type of the expression at the cursor.

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

The \scala.reflect.io\ package has been refactored to modernize file and directory handling. A new \AbstractFile\ base class and its implementations (\PlainFile\, \PlainNioFile\, \VirtualFile\, \VirtualDirectory\, \ZipArchive\) provide a unified abstraction over files, directories, and in-memory or JAR-backed resources. This change introduces a more consistent API for file operations, improves resource management (e.g., closing \ZipFile\ handles), and supports modern Java APIs (NIO) alongside legacy \java.io\ classes. The \Path\ abstraction is also refined to better distinguish between files and directories while maintaining a common interface for path manipulation.

src/reflect/scala/reflect/io · medium confidence

The reification code generation logic has been refactored into separate, focused traits: GenAnnotationInfos, GenNames, GenPositions, GenSymbols, GenTrees, GenTypes, and GenUtils. This change organizes the reifier's code generation responsibilities, separating concerns for annotations, names, positions, symbols, trees, and types, while introducing helper utilities for building mirror calls and factory calls.

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

The sbt-bridge has been refactored to support the new \AnalysisCallback3\ interface, which includes code actions and other enhanced diagnostic information. The bridge now attempts to use \AnalysisCallback3\ when available, falling back to the older \AnalysisCallback\ interface for compatibility with older sbt versions. This change enables the bridge to pass richer error and warning information, including code actions, back to the build tool, improving the developer experience when dealing with compilation issues.

src/sbt-bridge · high confidence

The scalap module's handling of Scala signatures has been restructured into distinct, focused classes: ClassFileParser for bytecode, ScalaSig for signature data, ScalaSigPrinter for output, and supporting types like Flags and Symbol. This change improves the internal organization of the classfile decoder, making the codebase easier to maintain and extend.

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

The compiler's backend was restructured by introducing a new \Platform\ trait and its \JavaPlatform\ implementation, which encapsulate platform-specific logic such as classpath management, equality method resolution, and compilation triggers. Additionally, \ScalaPrimitives\ was added to define constants for all supported primitive operations (arithmetic, bitwise, comparison, array, and coercion operations), providing a centralized mapping for these operations within the compiler.

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

The Scala compiler's utility classes have been reorganized into the \scala.tools.nsc.util\ package. This change introduces new files such as \CharArrayReader\, \ClassPath\, \DocStrings\, \EditDistance\, \Exceptional\, \InterruptReq\, \JarFactory\, \JavaCharArrayReader\, \ShowPickled\, \SimpleTracer\, \StackTracing\, \StringUtil\, and \WorkScheduler\ in the \src/compiler/scala/tools/nsc/util\ directory. These utilities support core compiler functionality, including character reading, classpath management, exception handling, and debugging/tracing.

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

The \async\ compiler phase has been refactored from a monolithic implementation into a set of distinct, reusable components (AnfTransform, AsyncAnalysis, AsyncPhase, ExprBuilder, Lifter, LiveVariables, StateAssigner, StateSet, TransformUtils). This change improves the structure and maintainability of the async transformation, which converts \async\ blocks into state machines. The new architecture separates concerns such as A-normal form (ANF) transformation, state machine construction, variable lifting, and live variable analysis, making the compiler's handling of \async\ blocks more robust and easier to extend.

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

The compiler's parser and scanner have been reorganized into a new set of files (BracePair, BracePatch, Change, CommonTokens, MarkupParsers, Parsers, Patch, Scanners, SymbolicXMLBuilder) to improve modularity and reduce duplication. This refactoring introduces new internal classes for tracking brace pairs and patches, extracts common token definitions, and separates XML parsing logic, which may affect internal compiler behavior and error reporting for syntax and position-related issues.

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

The typechecker (Typer) has been refactored to route error and warning reporting through the Context system, replacing the previous direct use of the global reporter. This change encapsulates the typechecker's state and error handling within the Context, allowing for more precise error positioning and better integration with the IDE and REPL. Additionally, the Typer's internal state has been simplified by removing the 'dyna' field and other redundant fields, while ensuring that all type-checking errors are now properly associated with their source positions for improved user feedback.

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

This update refactors the internal reflection implementation, introducing several behavioral changes and fixes. Key updates include: improved handling of Java annotations and varargs in reflection; better support for quasiquotes and macro expansion; and numerous bug fixes for crashes and regressions (e.g., SI-7876, SI-8129, SI-8086). The change also enhances the reflection API with new methods and flags (e.g., \SYNTHETIC\, \HIDDEN\), improves error reporting, and optimizes performance by reducing allocations and improving cache usage. Users may see changes in how reflection errors are reported and how certain types are handled during runtime reflection.

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

The \scala.reflect.reify\ package has been restructured into distinct modules: \Errors\ for handling reification exceptions and error messages, \Phases\ for the reification pipeline, \Reifier\ as the core logic, \States\ for managing reifier state, \Taggers\ for materializing type/class tags, and \package.scala\ for public entry points. This refactoring isolates error handling, state management, and tag materialization from the main reifier logic, improving maintainability and clarity of the macro reification process.

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

The \scala.reflect.macros\ package has been reorganized to improve the macro writing experience by splitting the \Context\ interface into focused, modular traits. New traits such as \Aliases\, \Attachments\, \Enclosures\, \Evals\, \FrontEnds\, \Infrastructure\, \Internals\, \Names\, \Parsers\, \Reifiers\, \Typers\, and \Universe\ now provide specific functionality (e.g., type checking, tree manipulation, and error reporting) as separate mixins. This change refines the macro context API, deprecating older, monolithic accessors in favor of these specialized interfaces, which allows macro authors to access only the reflection features they need.

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

The standard library has been restructured to define primitive value types (such as \Boolean\, \Byte\, \Int\, etc.) as direct subclasses of \AnyVal\, with their companion objects extending \AnyValCompanion\. This change introduces a new \AnyVal\ class and companion trait, while also updating the \App\ trait to reflect changes in the \DelayedInit\ mechanism. Users will see these types as the foundational building blocks for value classes, with improved documentation and internal organization.

src/library/scala · high confidence

The \scala.math\ package has been restructured to introduce new typeclasses and traits for numeric operations and ordering. \Numeric\, \Fractional\, and \Integral\ traits now provide a unified interface for numeric types, enabling generic numeric operations. \Ordering\ and \Equiv\ have been introduced to separate comparison and equality concerns, with \Ordering\ supporting multiple orderings per type. \BigDecimal\ and \BigInt\ have been updated to implement these new traits, and \Ordered\ and \PartiallyOrdered\ traits provide alternative comparison interfaces. This change affects how numeric and ordering operations are performed in the standard library.

src/library/scala/math · high confidence

The core data structures for Scaladoc comments, including \Comment\, \Body\, \Block\, and \Inline\ types, have been reorganized into the \scala.tools.nsc.doc.base.comment\ package. This move clarifies the project structure by separating base comment definitions from other model components, ensuring that the comment model is clearly defined in its own dedicated directory.

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

The Scaladoc diagram generator has been refactored to render inheritance and package diagrams using the Dagre-D3 JavaScript library instead of pre-generated SVGs. This change introduces new Scala components (DiagramGenerator, DotDiagramGenerator, DiagramStats) that generate DOT graph descriptions and embed JavaScript to render them dynamically in the browser. The implementation also adds performance tracking for diagram generation steps and includes logic to limit the number of displayed classes to prevent overcrowding.

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

The Scaladoc tool now provides summary reporting for errors and warnings, ensuring that the process exits with a non-zero exit code when errors occur, which improves integration with build systems and CI pipelines. Additionally, the main entry point for Scaladoc has been moved to a new file (ScalaDoc.scala) that consolidates the command-line processing, plugin warnings, and help text display.

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

The project's build configuration has been updated to use sbt-pgp version 2.3.1 for signing releases, replacing the previous version. Additionally, a new credentials file (credentials-private-repo-netrc) has been added to store authentication details for the Scala CI private repository, enabling automated publishing workflows.

admin/files · medium confidence

The main index page for Scala development tools has been updated to include the fast Scala compiler (fsc) alongside the standard tools (scala, scalac, scaladoc, scalap). The page now provides a structured list of these core utilities with links to their respective reference pages for Solaris, Linux, and Windows.

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

The Scala launcher scripts (tool-unix.tmpl and tool-windows.tmpl) have been updated to include a templated Apache 2.0 copyright header. The Windows batch file now disables delayed expansion during the final executable call to prevent issues with exclamation marks in quoted strings, and uses a workaround to correctly capture the process exit code. The Unix shell script now handles Cygwin, MinGW, and MSYS environments by converting paths using cygpath, and supports newlines in the JAVA\_OPTS environment variable.

src/compiler/templates · medium confidence

The distribution documentation now explicitly states that Scala is licensed under the Apache License 2.0, with copyright holders listed as EPFL and Lightbend, Inc. dba Akka. The README for the Scala distribution has been updated to reflect the Apache 2.0 license and points to the \doc/licenses\ directory for third-party licenses (BSD 3-Clause for ASM and JLine 3, MIT for jQuery).

doc · high confidence

This update addresses numerous bugs and performance issues within the compiler's transformation phases (such as Erasure, Specialization, and Delambdafy). Key changes include fixing crashes related to value classes, lambda handling, and specialized methods, as well as optimizing tail-call elimination and reducing memory allocations in the compiler's internal data structures.

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

Add Scala/Java interop test for nested class instantiation; Add Scala/Java interop test for varargs; Add TASTY test infrastructure and specific test cases; Add cycle-jsoup test suite; Add instrumentation tests for method call profiling; Add macro test suite for annotated tree copying; Add positive compilation tests for companion objects in package objects; Add presentation compiler tests for member visibility; Add regression test for SI-4365; Add test case for IDE crash on load; Add test case for eta expansion using local owner for binders; Add test case for raw type copying; Add test cases for Java wildcard bound inference; Add test cases for sealed class local child pickling; Add test coverage for TreeBrowsers; Add test coverage for classOf with object types; Add test coverage for issue \#2433; Add test coverage for refined type normalization; Add tests for macro attachment retention across type checking; Add tests for sys.env case-insensitive lookup and missing key behavior; Add unit tests for the Scala compiler's symbol table and name extraction logic; Added JMH-based benchmark suite for Scala collections; Added JUnit tests for AbstractFile and ZipArchive; Added JUnit tests for ControlThrowable and Exception handling; Added JUnit tests for JVM backend optimizations; Added JUnit tests for Scala Regex matching behavior; Added JUnit tests for Scala annotations and bytecode generation; Added JUnit tests for Scala collection classes; Added JUnit tests for Scala core library components; Added JUnit tests for Scala language features; Added JUnit tests for Scala/JDK interop converters; Added JUnit tests for StringContext and string interpolation; Added JUnit tests for internal utility classes; Added JUnit tests for mutable collections; Added JUnit tests for scala.io.Source; Added JUnit tests for scala.reflect.internal; Added JUnit tests for scala.util utilities; Added JVM tests for the async transformation; Added JVM-specific tests for annotations, BigInt, console, deprecation, and duration; Added Java 17+ test cases for sealed types and pattern matching; Added Java API tests for function, option, and stream converters; Added Java access modifier test cases; Added Java test case for Scala interop and collection signatures; Added Java test cases for inner class handling; Added Java test fixtures for TASTy pipeline; Added Java/Scala test cases for raw parent type handling; Added OSGi test suite for Scala; Added QUnit-based JavaScript tests for ScalaDoc index filtering; Added REPL completion and tabulation tests; Added Scala/Java interop test for Java method invocation; Added ScalaCheck tests for Java collection wrappers; Added Scaladoc test resources for Scala core types; Added Scaladoc test suite; Added TASTy reader tests for annotations, delayed types, and generic erasure; Added TASTy test infrastructure and scripts; Added TASTy test suite for Scala 3 annotations and delayed types; Added async test suite for Scala.js compatibility; Added automated numbering, table of contents, and version notice for the Scala specification; Added benchmarks for equality operations; Added bytecode and solving tests for pattern matching optimization; Added command-line spec usage demo to tests; Added comprehensive JUnit tests for Scala collection wrappers; Added comprehensive JUnit tests for Scala math types; Added comprehensive JUnit tests for Scala version parsing and compiler settings; Added comprehensive JUnit tests for immutable collections; Added comprehensive JUnit tests for the JVM backend; Added comprehensive JUnit tests for the Scala process library; Added comprehensive bytecode tests for Scala trait method forwarders; Added comprehensive test coverage for compiler determinism, phase assembly, and quickfixes; Added comprehensive test coverage for the Scala compiler bridge; Added comprehensive test coverage for the Scala compiler's classpath implementation; Added comprehensive test coverage for the ScalaP tool; Added comprehensive tests for primitive boxing and lambda deserialization; Added comprehensive unit tests for the Scala 2 typechecker; Added higher-kinded type matching test cases; Added instrumentation counters to runtime boxing and array methods; Added internal test infrastructure for TASTy run tests; Added jcstress concurrency tests for Scala collections; Added macro attachment tests; Added macro expansion discard test case; Added macro implementation and usage tests for SI-5744; Added macro position repair tests for SI-8064; Added macro resolution tests for Scala 3 source mode; Added macro test cases for knownDirectSubclasses; Added macro test cases for named argument handling with dependent method types; Added macro test suite for spurious 'pure expression does nothing' warning; Added macro tests for deferred type arguments; Added macro tests for whitebox context usage; Added macro-annot tests for kase annotations and various macro scenarios; Added negative test cases for TASTy interop edge cases; Added negative test coverage for async/await restrictions; Added negative tests for missing classpath dependencies; Added negative tests for unsupported Scala 3 features; Added new compiler regression tests for type inference and nested classes; Added new positive test cases for Java/Scala interop; Added new positive test cases for Scala/Java interop and object imports; Added new positive test cases for pattern matching and Java interop; Added new test cases for Java and Scala type handling; Added new test cases for Java signature generation; Added new test cases for Java/Scala interop and generic class handling; Added new test cases for Scala-Java interop scenarios; Added new test cases for issue \#3486; Added parser range position tests; Added pipelined compilation tests for Scala 3 TASTy; Added position tests for edge cases and Scaladoc comments; Added positive test cases for SQLBuilder; Added presentation compiler tests for completion, hyperlinks, and doc comments; Added presentation tests for IDE bug 1000475 and implicit member handling; Added property-based tests for Accumulator conversions and draining; Added property-based tests for Scala quasiquotes; Added property-based tests for Scala standard library collections; Added property-based tests for Scala's BigInt; Added property-based tests for immutable collections; Added random client/server socket test; Added regression test for cyclic reference issue \#10639; Added regression test for generic List handling; Added regression test for macro changeOwner behavior; Added regression test for scaladoc and tasty; Added regression tests for Java inner classfile reader; Added regression tests for Java/Scala interop and method overloading; Added regression tests for compiler issues; Added regression tests for empty package and Dotty issue i3816; Added regression tests for implicit import resolution; Added regression tests for issue \#4205; Added regression tests for value class separate compilation crasher; Added regression tests for various compiler bugs and features; Added run tests for TASTy unpickling and type system features; Added script test for manifest-based class-paths; Added scripted tests for source dependency analysis; Added scripted tests for the sbt compiler bridge; Added scripts and licenses for specification PDF generation; Added serialization and special duration tests; Added specification documentation stylesheets; Added test case for Java source file with duplicate member names; Added test case for Java type-use annotation handling; Added test case for issue \#3249; Added test case for macro reify cross-talk issue; Added test case for mixin issue; Added test case for owner initialization when searching for companion; Added test cases for @deprecatedInheritance and @deprecatedOverriding; Added test cases for IDE-1000567 / SI 5013; Added test cases for Java and Scala in t6978; Added test cases for Java and Scala syntax invariants; Added test cases for Java annotation handling; Added test cases for Java annotation modifiers; Added test cases for Java enum and Scala app interaction; Added test cases for Java import vs. defn. binding precedence; Added test cases for Java package detection; Added test cases for Java static name resolution ambiguity; Added test cases for Java varargs handling in Scala; Added test cases for Java/Scala interop in t1745; Added test cases for Java/Scala interop scenarios; Added test cases for Java/Scala interop with generic type overrides; Added test cases for SI-2458; Added test cases for SI-7596 to validate symbol curtailment during unpickling; Added test cases for SI-7596 to validate symbol overloading behavior; Added test cases for Scala pickling of higher-kinded types; Added test cases for Scala/Java annotation processing; Added test cases for annotation handling in t1029 and t1942; Added test cases for by-name implicits and macro implementations; Added test cases for companion class resolution; Added test cases for cycle detection in Scala/Java interop; Added test cases for cycle detection in generic interfaces; Added test cases for cyclic reference handling; Added test cases for equality checks on refined types; Added test cases for existential types with Java case classes; Added test cases for generic type parameter handling; Added test cases for infix completion scenarios; Added test cases for issue \#3349; Added test cases for issue SI-6245; Added test cases for lambda lifting behavior; Added test cases for macro expansion and annotated originals; Added test cases for macro expansion and unused import warnings; Added test cases for nullary override warnings; Added test cases for private value class constructor access; Added test cases for protected static members; Added test cases for raw type handling; Added test cases for scope completion; Added test cases for secondary constructors in macros; Added test cases for super class and interface implementation; Added test cases for type bounds in macros; Added test coverage for AbstractBase and Caller interaction; Added test coverage for GenBCode incoherent tree crash; Added test coverage for JEP 445 compact compilation units; Added test coverage for Java 8+ features; Added test coverage for Java annotation handling; Added test coverage for Java annotation processing; Added test coverage for Java array return type override; Added test coverage for Java deprecation handling; Added test coverage for Java enum constants in annotations; Added test coverage for Java generic signature handling with Scala traits; Added test coverage for Java import and level 4 definition interactions; Added test coverage for Java import shadowing and resolution; Added test coverage for Java inherited type handling in protobuf; Added test coverage for Java interop type mismatch; Added test coverage for Java interop with Any/Object and Java wildcards; Added test coverage for Java interop with nested static classes; Added test coverage for Java protected inner class access; Added test coverage for Java static import from subclass; Added test coverage for Java type parameter handling; Added test coverage for Java varargs overload resolution; Added test coverage for Java/Scala interaction in t1263; Added test coverage for Java/Scala interop unification; Added test coverage for SI-10159 spurious cyclic error in type selection; Added test coverage for SI-9356 backend assertion; Added test coverage for Scala HashMap usage; Added test coverage for Scala None/Nothing handling in Java; Added test coverage for Scala/Java interop with raw types; Added test coverage for abstract enum methods and pattern matching; Added test coverage for access boundary checks between protected Java members; Added test coverage for annotation processing; Added test coverage for assignment rewrite; Added test coverage for boxed runtime value handling; Added test coverage for case class implicit parameters and macro annotations; Added test coverage for custom unapplication typechecking; Added test coverage for existential abstract unrelatable skolems; Added test coverage for fplib Show API and Impl traits; Added test coverage for generic abstract class inheritance; Added test coverage for handling constant literal annotation arguments; Added test coverage for implicit ambiguity in package objects; Added test coverage for implicit package object conversions; Added test coverage for import ambiguity resolution; Added test coverage for inline optimization with pattern selections; Added test coverage for issue \#4402; Added test coverage for issue SI-942; Added test coverage for macro annotation deprecation warnings; Added test coverage for macro attachment preservation across type-checking; Added test coverage for macro expansion with implicits; Added test coverage for macro implementation SI-8352; Added test coverage for macro refinements and whitebox context usage; Added test coverage for macro reset behavior; Added test coverage for macro-based type derivation; Added test coverage for nullary override warnings; Added test coverage for pattern-matching analysis with large enums; Added test coverage for private top-level symbol import errors; Added test coverage for raw type regression under separate compilation; Added test coverage for separate compilation scenario; Added test coverage for static Java member accessibility; Added test coverage for static forwarder generation; Added test coverage for static forwarders in case classes; Added test coverage for the SI-9111 inliner workaround; Added test coverage for trait linearisation and method overriding; Added test coverage for unreachability analysis; Added test coverage for unused macro warnings; Added test file for issue \#1937; Added test files for callcc-interpreter and ping-pong; Added test filtering configuration for JVM warnings; Added test fixtures for Scala numeric conversion interfaces; Added test for BCode handling of throw null; Added test for Java calling Scala HashMap; Added test for Scala-Java annotation mismatch; Added test for compiler crasher under separate compilation with param aliasing and overloads; Added test for delambdafy transformation; Added test for given class in tastytest.givens; Added test for idempotent presentation compilation of implicit classes; Added test for mixing object in trait into package object; Added test for parsing private interface methods in Java; Added test for pattern retypechecking on case companion aliases; Added test for presentation compiler crash on base type cache invalidation; Added test for preserving declaration order through pickle/unpickle; Added test for printing behavior in the negative test suite; Added test for typecheck silent mode suppressing ambiguous errors; Added test for unpickling local sealed children; Added test infrastructure for TASTy intent-based testing; Added test suite for the -Ystop-after:parser compiler flag; Added test suite for the Xplugin descriptor scanning feature; Added test suite for the async compiler phase; Added tests for -Yimports implicit preamble imports; Added tests for AnnotatedTypes pickling; Added tests for Future failure-fast behavior and callback deregistration; Added tests for JDK 16+ record support; Added tests for JVM 21+ switch expressions and enum pattern matching; Added tests for JVM backend analysis components; Added tests for Java annotation array parsing; Added tests for Java annotation parsing; Added tests for Java class literals on raw types; Added tests for Java field override behavior; Added tests for Java member lookup in inherited types; Added tests for Java protected inner classes and modules loaded by classpath; Added tests for Java type import support; Added tests for MurmurHash3 consistency and alignment; Added tests for Scala 2 erasure with value class parameters; Added tests for Scaladoc model generation and diagram rendering; Added tests for Scaladoc syntax highlighting and URL template handling; Added tests for collection generic decorators; Added tests for companion objects in package objects under separate compilation; Added tests for compiler phase assembly; Added tests for compiler reporter and code action functionality; Added tests for concurrent map operations and null value handling; Added tests for experimental definition usage restrictions; Added tests for generic signature handling with shadowed type parameters; Added tests for inlining in constructors; Added tests for issue \#2464; Added tests for lazy completion of LambdaType param symbols; Added tests for local dummy symbol unpickling; Added tests for macro and by-name implicit interactions; Added tests for macro annotation parameter usage and expansion behavior; Added tests for macro annotation unused parameter warnings; Added tests for macro implementation details; Added tests for macro position handling in TASTy; Added tests for macro string interpolation warnings; Added tests for nested Java class parsing; Added tests for opaque types; Added tests for package object and value access; Added tests for package object case class handling; Added tests for package object inheritance and naming conflicts; Added tests for package object type resolution; Added tests for package object warnings; Added tests for partial function desugaring; Added tests for primitive type behavior and edge cases; Added tests for procedure syntax deprecation; Added tests for raw type handling in Java sources; Added tests for reflection runtime null-safety and thread-safety; Added tests for root context specification; Added tests for selections on package objects; Added tests for shadowed import warnings; Added tests for stack trace formatting; Added tests for the no-annotations flag; Added tests for tuples 15-22; Added tests for unpickling local sealed children; Added tests for unused macro and lint warnings; Added tests for whitebox macro unapply and unapplySeq patterns; Added unit tests for DefaultPromise implementation; Added unit tests for Scala reflection; Added unit tests for compiler transform phases; Added unit tests for macro Attachments; Expanded TASTy test coverage for Scala 3 features; Expanded negative test coverage for Scala 3 features; Expanded negative test coverage for compiler warnings and errors; Expanded property-based testing coverage for core collections and utilities; Expanded property-based tests for collection parsing and iteration; Expanded test coverage for Scala specialization; New core test infrastructure for the Scala presentation compiler; New interactive compiler test infrastructure; Scaladoc test suite expanded with new resource files; Updated test configuration for Scaladoc.

The project's build system has been migrated from Ant to sbt, introducing a new \build.sbt\ configuration that defines the Scala compiler, library, and test subprojects. This change updates key dependencies including JUnit (4.13.2), ScalaCheck (1.18.1), and JLine (3.x), while also adding a \Gemfile\ to manage Ruby dependencies like Jekyll and Redcarpet for documentation generation.

(dependencies) · high confidence

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

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

• Code Health 100
• Architecture 100
• Maturity 62
• Readiness 74
• Security 54
• Accessibility 59

• 300 commits — 272 feature/other, 28 fixes

• (repo) — 150 commits
• (root) — 32 commits
• test/files — 22 commits
• src/library — 20 commits
• src/compiler — 18 commits
• project/plugins.sbt — 11 commits
• project/build.properties — 9 commits
• src/reflect — 7 commits
• .github/workflows — 6 commits
• src/scaladoc — 5 commits
• admin/files — 4 commits
• project/MimaFilters.scala — 2 commits
• src/intellij — 2 commits
• test/junit — 2 commits
• .github/CODEOWNERS — 1 commit
• .github/dependabot.yml — 1 commit
• project/DottySupport.scala — 1 commit
• scripts/travis-publish-spec.sh — 1 commit
• spec/08-pattern-matching.md — 1 commit
• src/repl-frontend — 1 commit

• fix: Adjust apt source for postgres, fixes apt update on spec build
• fix: Fix IsIterableOnce scaladoc
• fix: Fix mask check in LongMap
• fix: Fix scala-reflect scaladoc link
• fix: Fixes for central repository publishing
• fix: Merge pull request #11108 from lrytz/travis-fix
• fix: Merge pull request #11110 from lrytz/travis-fix-revert
• fix: Merge pull request #11142 from lrytz/central-fix
• fix: Merge pull request #11144 from dragos/dragos/backport-import-selector-fix
• fix: Merge pull request #11147 from SethTisue/fix-mima-on-jdk-25
• fix: Merge pull request #11162 from lrytz/t13128-revert
• fix: Merge pull request #11165 from lrytz/pr11021-revert
• fix: Merge pull request #11178 from dragos/dragos/backport-base-type-crash-fix
• fix: Merge pull request #11186 from lrytz/revert-ordering
• fix: Merge pull request #11201 from artimahub/feature-scala2-mood-period-backticks-fixed
• fix: Merge pull request #11243 from bluelhf/fix/array-ops-transpose
• fix: Revert "Adjust apt source for postgres"
• fix: Revert "[backport] Tweak variance of Ordering.min and .max"
• fix: Revert JLine to version 3.29.0 for Scala 2.13.17
• fix: Revert lint:infer-any warning when inferring Any/Nothing for HK
• …and 280 more

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

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.