twitter/rsc

This release delivers a comprehensive architectural overhaul of the Rsc compiler, introducing full Java source file parsing and scanning support alongside a modularized internal structure for the Scala parser, scanner, and semantic analysis. Significant behavioral changes include stricter error reporting for missing type parameters and trailing commas, improved name resolution in the outliner, and the addition of a new RscCompat Scalafix rule for Scala 2.12 compatibility. The update also introduces new tooling such as a \scalap\ CLI for inspecting Scala signatures, JMH benchmarks for compilation phases, and expanded test coverage for semantic and parsing checks.

The Java parser now supports parsing Java source files, including classes, interfaces, enums, fields, methods, constructors, imports, and type definitions. This enables the tool to process Java code alongside Scala, allowing mixed-language projects to be parsed and analyzed.

rsc/src/main/scala/rsc/parse/java · high confidence

The repository now includes new executable scripts in the bin directory to streamline development workflows. A new \bin/bench\ Python script allows users to run benchmark suites and parse performance logs. A \bin/ci\ script provides a wrapper for running SBT commands in CI environments. Additionally, \bin/scalafix\ and \bin/scalafmt\ are added as bootstrapping scripts that download and cache specific versions of the Scalafix (0.9.8) and Scalafmt (1.2.0) tools, ensuring consistent tooling across environments.

bin · high confidence

Introduces a new \scalap\ command-line interface for parsing and displaying Scala signature data from classfiles. Users can now run \scalap\ to inspect classfiles, with support for both low-level and high-level output formats via the \-lowlevel\ and \-highlevel\ flags. The tool handles both \ScalaSignature\ and \ScalaLongSignature\ annotations, enabling better debugging and analysis of compiled Scala code.

scalasig/scalasig · high confidence

New benchmark classes have been added to the bench module, providing performance measurements for Rsc and Scalac across various compilation phases including parse, outline, index, ScalaSig, SemanticDB, and full compilation. These benchmarks utilize the JMH framework to measure execution time for each phase, allowing for performance comparison and optimization of the compiler's internal stages.

bench · high confidence

The rsc/scan/java package now includes a complete Java scanner, providing tokenization support for Java source files. This new component enables the compiler to lexically analyze Java code, handling identifiers, keywords, operators, literals, and comments, which is a prerequisite for parsing and processing Java sources.

rsc/src/main/scala/rsc/scan/java · high confidence

The commit copies un-rewritten versions of core concurrency classes—including AsyncMeter, AsyncMutex, AsyncQueue, AsyncSemaphore, AsyncStream, Broker, Offer, Once, Permit, Scheduler, Serialized, Spool, and SpoolSource—into the examples/original/core directory. These files, each annotated with a scalafix comment for RscCompat, serve as the baseline or reference implementation for these components, preserving the original code before any automated rewriting or refactoring is applied.

examples/original/core · high confidence

The scalafix/rules/util package now includes GlobalImports, a utility class that manages the insertion of global import statements to shorten qualifiers, and MemoizeUtil, a trait providing a memoization helper for caching function results. These new components support internal rule logic by enabling more efficient import management and result caching.

scalafix/rules/src/main/scala/rsc/rules/util · high confidence

The examples/syntactic directory now includes new Scala source files (102–175, 220, 369, 393, 427) that demonstrate various syntactic constructs, including implicit parameters, type aliases, pattern matching, for-comprehensions, string interpolation, and trailing commas in function arguments.

examples/syntactic · high confidence

Added a new Main class in the rsc.cli package that serves as the entry point for the compiler. This implementation includes logic to expand arguments prefixed with '@' by reading and splitting the contents of the specified file, allowing users to pass arguments via external files.

rsc/src/main/scala/rsc/cli · high confidence

A new \RscCompat\ rule has been added to automatically insert type ascriptions and optional auto-imports to improve compatibility with Scala 2.12. The rule supports a \better\ mode (enabled by default) that ascribes inferred types to values, definitions, and pattern definitions, and an \autoimport\ configuration option to automatically insert import statements to shorten qualifiers.

scalafix/rules/src/main/scala/rsc/rules · high confidence

The lexis module now includes dedicated token and keyword definitions for Java and Scala. For Java, new files define a comprehensive set of Java keywords (such as abstract, class, interface) and associated token constants. For Scala, the codebase introduces a broader set of Scala-specific keywords (including def, val, trait, match) and token constants, along with a Names trait that provides utility methods for analyzing Scala identifiers (e.g., determining operator associativity, precedence, and pattern variable status). These changes lay the groundwork for language-specific lexical analysis by separating the token sets and keyword mappings for each language.

rsc/src/main/scala/rsc/lexis · high confidence

The \check\ directory now contains a new suite of comparison tools: \checkbytecode\ for comparing compiled class files, \checkparse\ for comparing parsed ASTs, \checkscalasig\ for comparing Scala signature files, and \checkoutline\ for comparing semantic database outlines. These tools provide a unified base for comparing compiler outputs, including shared utilities for caching, fingerprinting, and diffing. Additionally, a \diffoutline\ tool is introduced to compare outline files directly.

check · high confidence

Added new Gensym and Gensyms classes to the rsc.gensym package. The Gensym class provides a simple mechanism for generating unique string identifiers based on a given prefix, while the Gensyms class manages a collection of Gensym instances, each associated with a specific Input. This change introduces new functionality for generating unique identifiers within the RSC compiler.

rsc/src/main/scala/rsc/gensym · high confidence

The \rsc.syntax\ package now includes \Dupe.scala\, which provides a \dupe\ method on syntax tree nodes to create deep copies of the abstract syntax tree. This addition supports internal compiler operations that require independent copies of the tree structure, such as safe mutation or parallel processing, without affecting the original nodes.

rsc/src/main/scala/rsc/syntax · high confidence

Added new Scala source files (Positions.scala, Trees.scala, package.scala) in the scalafix/rules/syntax directory. These introduce helper traits that provide utility methods for working with Scala meta AST nodes, including extracting inferred definitions, checking visibility modifiers, and converting positions to ranges. This provides internal tooling for rule implementations to analyze and transform code structures more easily.

scalafix/rules/src/main/scala/rsc/rules/syntax · high confidence

The repository now includes essential project configuration and documentation files. A \.gitignore\ file is added to exclude build artifacts and IDE settings. A \.scalafmt.conf\ file configures the Scala code formatter, setting the maximum column width to 100 and disabling specific formatting rules. The \.travis.yml\ file establishes the CI pipeline, specifying the use of Ubuntu Trusty, Scala 2.12.10, and various CI commands. The \README.md\ is updated to reflect the project's current status, goals, and documentation links. Additionally, \LICENSE\ (Apache 2.0) and \NOTICE.md\ (containing BSD and MIT license texts for derived works) are added to satisfy legal requirements.

(repo-wide) · high confidence

The Scanner is now a trait that delegates to language-specific implementations for Scala and Java, allowing the tool to process Java source files alongside Scala. For any unrecognized language, the scanner now crashes with a clear error message rather than failing silently or throwing an unhandled exception.

rsc/src/main/scala/rsc/scan · high confidence

The SemanticDB generation logic in rsc/semanticdb has been refactored into separate, modular traits (Bounds, Converter, Defns, Eligibility, Infos, LinkMode, Lits, Modifiers, Params, Prefixes, Scopes, Templates, Tpts, Writer) to improve code organization and maintainability. This change restructures how semantic information is converted and written, separating concerns like type conversion, symbol information, and file writing into distinct components.

rsc/src/main/scala/rsc/semanticdb · high confidence

The rsc.symtab package has been refactored to improve modularity and reduce coupling within the symbol table implementation. The previously monolithic Symtab class has been split into distinct, reusable traits—Desugars, Envs, Metadatas, Outlines, Scopes, and Sketches—which are now mixed into the final Symtab class. This change reorganizes how the compiler manages symbol information, outlines, and environment data, providing a more modular internal structure for symbol table operations.

rsc/src/main/scala/rsc/symtab · high confidence

The utility package was restructured to improve error handling and code organization. The previous error handling mechanism was replaced with a new 'CrashUtil' and 'CrashException' system that provides more detailed and safe error reporting for compiler crashes. Additionally, various helper traits were introduced or reorganized, including 'CharUtil' for character classification, 'TreeUtil' for AST manipulation, 'SemanticdbUtil' for semantic database operations, 'ProtobufUtil' for serialization, 'StreamUtil' for byte stream handling, 'StringUtil' for string manipulation, and 'ThrowableUtil' for exception stringification. This refactoring consolidates these utilities into the 'rsc.util' package, making them more accessible and consistent across the codebase.

rsc/src/main/scala/rsc/util · high confidence

The semantic analysis logic in the \rsc.rules.semantics\ package has been restructured into new, dedicated files: \Env\ for managing scope chains and name lookups, \Scopes\ defining the hierarchy of scopes (including \AddedImportsScope\ for handling imports and renames, and \TemplateScope\ for template linearization), and \Symbols\ for type alias equivalence checks. This change improves how the tool resolves symbols, handles renamed imports, and verifies type aliases, making the underlying semantic engine more modular and maintainable.

scalafix/rules/src/main/scala/rsc/rules/semantics · high confidence

The Scala parser implementation has been refactored from a single large file into multiple smaller, focused traits (such as Bounds, Contexts, Defns, Imports, etc.) within the rsc.parse.scala package. This change improves code organization and maintainability by separating concerns like token handling, literal parsing, and definition parsing into distinct modules.

rsc/src/main/scala/rsc/parse/scala · high confidence

New Scala source files were added to the examples/deps1 and examples/deps2 directories. These files define simple object structures (M.X, M.I.X) and type aliases (T = M.X, T = M.I.X) to reproduce a related bug, serving as test cases for the underlying issue.

examples/deps1, examples/deps2 · medium confidence

The outliner has been rewritten to improve name resolution and outlining accuracy. This change introduces a new \Env\ class to track the lexical environment and a \Scheduler\ to manage the outlining work queue. The \Env\ class now handles symbol resolution by iterating through a stack of scopes, prioritizing explicit imports over wildcards. The \Scheduler\ is responsible for assigning symbols to identifiers and generating synthetic members for case classes, enums, and implicit classes. This refactoring addresses numerous bugs related to incorrect name resolution, missing definitions, and crashes on edge cases like higher-kinded type parameters and anonymous type parameters.

rsc/src/main/scala/rsc/outline · high confidence

The rsc/Compiler.scala file was introduced to centralize the compilation pipeline, replacing the previous scattered orchestration logic. This change groups the parse, index, schedule, outline, semanticdb, and scalasig phases into a unified execution flow, improving maintainability and clarity of the compilation process.

rsc/src/main/scala/rsc · high confidence

The compiler now enforces stricter checks on class and trait definitions. Specifically, it now reports an error when a class outline (e.g., an abstract class or trait) is initialized with missing type parameters, addressing issue \#410. Additionally, the parser now correctly handles and reports errors for trailing commas in argument lists, fixing issue \#427. New example files (408.scala, 410.scala, 427.scala) demonstrate these error conditions.

examples/error · medium confidence

The internal implementation of semantic rules has been refactored to support two different strategies for resolving symbol information. A new \BetterDocumentSymbols\ class is introduced, which maintains a local cache of symbol information, while the existing \RegularDocumentSymbols\ strategy is preserved. The \SemanticdbRule\ abstract class now accepts a \better\ boolean parameter to select between these two symbol table implementations, allowing for more efficient symbol lookups in specific scenarios.

scalafix/rules/src/main/scala/scalafix · medium confidence

The \SemanticdbPrinter\ was refactored to improve how types are printed. Function types now include correct parenthesization for single tuple arguments and by-name arguments. Single types are shortened if they are type-aliased or if auto-imports are enabled. Additionally, structural types no longer include \AnyRef\ or \Object\ when the \better\ config is active, and the printer handles renamed imports and package object prefixes more accurately.

scalafix/rules/src/main/scala/rsc/rules/pretty · medium confidence

The compiler now uses a new \Output\ abstraction to manage where compilation artifacts are written. This introduces two storage modes: \DirectoryOutput\ for writing to a directory, and \JarOutput\ for writing to a JAR file. The \JarOutput\ implementation is configured to use no compression (\NO\_COMPRESSION\) for the JAR entries. The \Output\ factory automatically selects the appropriate implementation based on whether the output path ends with \.jar\.

rsc/src/main/scala/rsc/output · high confidence

The project now uses an sbt build definition (Build.scala, plugins.sbt, and build.properties) to manage the build, including new commands for formatting (scalafmt), running tests (fast/slow), and executing JMH benchmarks (benchAll, benchParse, etc.). The build also integrates sbt-scalafix for code rewriting and adds convenience aliases for CI and publishing.

project · high confidence

Added new core data structures to the \rsc.semantics\ package, including \Metadata\ (with \OutlineMetadata\, \ClasspathMetadata\, and \NoMetadata\), \Name\ (with \TermName\ and \TypeName\), \Stdlib\ (defining standard library class symbols), \Symbols\ (defining symbol creation and operations), and \Values\ (for generating anonymous and local names). These changes streamline the terminology and data models around core semantic information, enabling more precise handling of symbols, names, and metadata within the compiler's semantic analysis phase.

rsc/src/main/scala/rsc/semantics · medium confidence

The Java classpath loader in rsc now parses Java generic type signatures directly from classfiles using the ASM library. This change introduces a new set of classes (JavaTypeSignature, ClassSignature, etc.) and ASM visitors to interpret JVM signature attributes, enabling more accurate reflection of Java generic types and type parameters in the semantic database.

rsc/src/main/scala/rsc/classpath/javacp · medium confidence

The examples in the core module have been rewritten to use the new RscCompat, which likely changes how the code is compiled or linked. Additionally, the codebase has been updated to replace the legacy \TupleN\[args\]\ syntax with the modern \(args)\ tuple syntax, ensuring compatibility with newer Scala versions.

examples/core · high confidence

The compiler's reporting system has been refactored into a new \rsc.report\ package, introducing a \Reporter\ trait and concrete implementations (\ConsoleReporter\, \StoreReporter\) that handle message output. This change introduces a \Message\ data model with distinct severity levels (Fatal, Error, Warning, Verbose) and specific message types for syntax and parsing errors, allowing users to see structured error summaries and detailed diagnostic information during compilation.

rsc/src/main/scala/rsc/report · high confidence

The ScalaSig serialization logic has been refactored into a new \rsc.scalasig\ package, introducing dedicated classes for managing symbol tables (\Mtab\), entry caching (\Entries\), and pickling (\Pickle\). This change restructures how the compiler generates ScalaSig files, separating concerns for symbol resolution, type emission, and output writing, which improves maintainability and supports future features like macro implementation emission.

rsc/src/main/scala/rsc/scalasig · high confidence

The rsc.pretty package has been restructured and expanded to support more robust code generation. This includes a new Printer class for managing indentation and formatting, a Str typeclass for human-readable string representations, and a Repl typeclass for generating executable Scala code. The refactoring introduces dedicated formatters for various AST nodes (such as PrettyTree, PrettyToken, and PrettyWork) and improves the handling of escape sequences and whitespace. These changes enhance the quality and correctness of the generated output, particularly for complex expressions and type patterns.

rsc/src/main/scala/rsc/pretty · high confidence

The \rsc.classpath.scalacp\ package was restructured into distinct Scala files (\LinkMode\, \Refs\, \Scalacp\, \Scalalib\, \Scopes\, \SymbolInformations\, \Symbols\, \Types\) to separate concerns. This change introduces \LinkMode\ to handle symlink and hardlink strategies, extracts symbol-to-semanticdb conversion logic into \SymbolInformations\ and \Scalalib\ for built-in types, and moves type and signature mapping into \Types\. Users benefit from a more maintainable internal structure that correctly resolves \ExtModClassRef\ symbols and handles empty/root packages without special-casing, ensuring accurate symbol information is generated for the classpath.

rsc/src/main/scala/rsc/classpath/scalacp · high confidence

The Scala scanner implementation in rsc/scan/scala has been split into separate, focused traits and classes: Characters for character access, History for state snapshotting, Messages for error reporting, and Xml for XML parsing. This modularization improves code organization and maintainability of the scanner.

rsc/src/main/scala/rsc/scan/scala · high confidence

The classpath resolution logic has been completely rewritten to load classpath entries directly from the filesystem and JAR files, replacing the previous implementation. This change introduces a new \Index\ and \Locator\ system that maps semantic symbols to their corresponding \.class\ or \.jar\ locations, improving debuggability and error messages for bad classpaths. The \Classpath\ class now uses a lazy-loading strategy with caching, and handles both uncompressed and compressed (JAR) entries, aligning behavior more closely with standard Java and Scala compilers.

rsc/src/main/scala/rsc/classpath · high confidence

The Rsc compiler's configuration model has been restructured to allow users to explicitly choose which compiler artifacts are generated and which Scala ABI to target. Users can now specify the target ABI version (2.11 or 2.12) via the \-abi\ flag, and can control the generation of SemanticDB or ScalaSignature artifacts via the \-artifacts\ flag. This provides more granular control over the output produced by the compiler.

rsc/src/main/scala/rsc/settings · high confidence

This update resolves several code generation issues in the Scala 3 examples. It ensures that accessors are correctly emitted for private members in traits, prevents the generation of duplicate equals and hashCode methods when they are already defined, and correctly handles default parameters in abstract methods for interfaces. Additionally, it fixes the handling of sealed traits and ensures primary constructors are always persisted regardless of visibility.

examples/deps3 · medium confidence

This update resolves numerous discrepancies and crashes in the semantic outliner, improving support for complex Scala and Java language features. Key fixes include handling case classes with more than 22 fields, implicit classes with higher-kinded type parameters, and abstract case classes. The outliner now correctly processes Java enums, annotations, and static inner classes, as well as Scala-specific constructs like package objects, path-dependent types, and self-referencing types. Additional improvements address name resolution for renamed imports, default parameter handling in interfaces, and the generation of accessors for private members in traits.

examples/semantic · high confidence

Added comprehensive test suites for compiler checks and semantic analysis; Added test fixtures for RscCompat and BetterRscCompat; Added test fixtures for RscCompat rule; Added test infrastructure for RscTests, FileFixtures, and ToolUtil; Updated Scala Predef signature test fixtures.

The build configuration has been updated to use Scalameta version 4.1.6, along with ScalametaScalacPlugin 4.2.5, ScalaTest 3.0.5, and various other library dependencies such as Logback 1.2.3, Better-Files 3.8.0, and ASM 6.0. This ensures the project uses the latest stable versions of these core libraries.

(dependencies) · high confidence

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

• CAI 45 → 62 (+16.4)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 100 → 75 (-24.6)
• Architecture 69 → 99 (+29.7)
• Maturity 54 → 54 (+0.4)
• Readiness 20 → 58 (+37.5)
• Security 97 → 78 (-19.7)

• Dimension evaluation failed
• Medium: security finding (details withheld)
• No automated tests
• No exposed public API
• No tests found
• Test reliability not included
• The related-work comparison is excellent but the document ends at a clipped marker ("We believe that Dotty and Rsc have complementary goals...") without mentioning the roadmap or contributing docs, which are present in the table of contents. (docs/relatedwork.md)

• Binaries.apply (cognitive 20) (scalasig/scalasig/src/main/scala/scala/meta/scalasig/Binaries.scala)
• Change coupling: Scheduler.scala ↔ Dupe.scala (rsc/src/main/scala/rsc/outline/Scheduler.scala)
• Change coupling: TreeStr.scala ↔ Dupe.scala (rsc/src/main/scala/rsc/pretty/TreeStr.scala)
• Checker.check (cognitive 20) (check/src/main/scala/rsc/checkoutline/Checker.scala)
• Checker.check (cyclomatic 16) (check/src/main/scala/rsc/checkoutline/Checker.scala)
• ClassTooLong: TreeStr (rsc/src/main/scala/rsc/pretty/TreeStr.scala)
• ClassfileCodec.fromBinary (cognitive 16) (scalasig/scalasig/src/main/scala/scala/meta/internal/scalasig/ClassfileCodec.scala)
• ClassfileReader.decode7to8 (cognitive 31) (scalasig/scalasig/src/main/scala/scala/meta/internal/scalasig/ClassfileReader.scala)
• ClassfileWriter.encode8to7 (cognitive 24) (scalasig/scalasig/src/main/scala/scala/meta/internal/scalasig/ClassfileWriter.scala)
• Classpath.load (cognitive 20) (rsc/src/main/scala/rsc/classpath/Classpath.scala)
• Compiler.run (cognitive 17) (rsc/src/main/scala/rsc/Compiler.scala)
• DefnOps.access (cognitive 22) (rsc/src/main/scala/rsc/semanticdb/Defns.scala)
• DefnOps.access (cyclomatic 17) (rsc/src/main/scala/rsc/semanticdb/Defns.scala)
• DefnOps.properties (cognitive 39) (rsc/src/main/scala/rsc/semanticdb/Defns.scala)
• DefnOps.properties (cyclomatic 41) (rsc/src/main/scala/rsc/semanticdb/Defns.scala)
• Defns.defnDef (cognitive 26) (rsc/src/main/scala/rsc/parse/scala/Defns.scala)
• Defns.defnValOrVar (cognitive 17) (rsc/src/main/scala/rsc/parse/scala/Defns.scala)
• Defns.templateStats (cognitive 21) (rsc/src/main/scala/rsc/parse/java/Defns.scala)
• Documentation: no usage examples (docs/contributing.md)
• Dormant codebase
• …and 788 more

• Containers 0 added · 0 removed · contexts 1 added · 0 removed · edges 0 added · 0 removed

• repository

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

twitter/rsc 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.