soutaro/steep

Steep is a static type checker for Ruby that validates code against RBS type signatures. It provides a persistent daemon server with LSP support for IDE integration, enabling features like hover information, code completion, and symbol search. The system performs incremental type checking with a master-worker architecture to optimize performance and offers comprehensive diagnostic reporting for both Ruby source and RBS definitions.

28 changes.

This period focused on the Steep 2.1.0 release, introducing a persistent daemon server for faster type checking and upgrading the parser to support Ruby 3.3 and 3.4. The work included a major library restructuring into a modular architecture, the addition of development and profiling utilities, and extensive smoke testing to validate type inference and error reporting across various Ruby constructs.

29 changes.

This period focused on a comprehensive rewrite of Steep's core type-checking engine, introducing a new subtyping system with constraint solving, expanded AST type classes, and modular type inference components. Concurrently, the project adopted a master-worker architecture for the language server to enable concurrent processing and introduced symbol indexing for enhanced IDE navigation.

31 changes.

This period focused on restructuring the diagnostic system for LSP compatibility and introducing a dedicated service layer for type checking and code intelligence. It involved adding comprehensive RBS type signatures across the entire codebase to enable static type checking of Steep's internals, while expanding test coverage for both Ruby and RBS diagnostics.

13 changes.

This period focused on introducing a persistent Steep daemon with LSP JSON-RPC support to maintain a warm RBS environment for faster type checking. The completion provider was refactored into specialized RBS and Ruby modules to improve context-aware suggestions, while new features included top-level self type annotations and improved union type narrowing in else branches.

New RBS signature files have been added for the \TypeApplication\ and \TypeAssertion\ classes within the \Steep::AST::Node\ module. These signatures define the public interface for these AST nodes, including methods for retrieving type information (\types\, \type\), accessing source location and string representations, and parsing logic. This provides type-checking coverage for the internal representation of type applications and assertions in the Ruby codebase.

sig/steep/ast/node · high confidence

Added RBS signature files for the AST module, defining types for annotations (including return, block, self, instance, module, break, method, variable, constant, instance variable, implements, and dynamic types), built-in types (such as Object, Array, Hash, String, Integer, Float, Symbol, Regexp, NilClass, Proc, Kernel, and Method, along with utility methods for nil, any, boolean, bottom, top, optional, true, and false types), ignore directives (including buffer scanning, ignore start/end, and line-level ignore with diagnostics), and core type definitions (covering Any, Boolean, Bot, Nil, Top, Void, Literal, Class, Instance, Self, Intersection, Record, Tuple, Union, Name variants, Proc, Var, and various Logic types).

sig/steep/ast · high confidence

Added RBS type signatures for the \Steep::AST::Annotation::Collection\ class, defining its attributes (such as \annotations\, \factory\, \context\, and various type annotation hashes) and methods (including \absolute\_type\, \var\_type\, \method\_type\, \self\_type\, and \merge\_block\_annotations\). This provides static type checking support for the annotation collection logic within the Steep AST module.

sig/steep/ast/annotation · high confidence

This change introduces a comprehensive set of RBS signature files (\.rbs\) for the Steep type checker's internal modules, including the CLI, daemon, source parsing, type construction, and locator. These signatures define the public interfaces for classes such as \Steep::CLI\, \Steep::Daemon\, \Steep::Source\, and \Steep::TypeConstruction\, enabling static type checking of Steep's own codebase and improving IDE support for its internal APIs.

sig/steep · high confidence

The project introduces a new set of RBS signature files in the \sig/shims\ directory to provide type checking for both internal modules and external libraries. These shims define types for the Language Server Protocol (LSP) constants and interfaces, the \Parser\ gem (including Ruby 3.1, 3.2, and 3.3 support), the \Prism\ parser (including Ruby 3.3 and 3.4 support), \concurrent-ruby\, \bundler\, \etc\, \exception\, \socket\, and \string\. This enables stricter type checking for the LSP implementation and its underlying parsing infrastructure.

sig/shims · high confidence

This change introduces RBS signature files (\.rbs\) for the \Steep::Project\ subsystem, defining the type structure for the project DSL, targets, groups, patterns, and options. Users benefit from improved static type checking and IDE support for the Steepfile configuration, including explicit types for library options, source/signature patterns, and code diagnostics configuration.

sig/steep/project · high confidence

Added RBS type definition files for the Steep AST type system, covering core types such as Any, Boolean, Bot, Class, Instance, Nil, Proc, Record, Self, Top, Tuple, Union, Var, and Void, along with supporting modules like Factory, Helper, Logic, and Name. These signatures define the public API, including methods for substitution, string representation, hashing, and type mapping, enabling static type checking of the AST layer itself.

sig/steep/ast/types, sig/steep/services · high confidence

This change introduces the RBS type definition file (sig/steep.rbs) for the Steep project, establishing type contracts for the main Steep module and the GCCounter module. For users, this provides static type checking support for the core API, including the new \ui\_logger\ accessor for user interaction messages, the \measure\ method which now accepts an optional \threshold\ keyword argument, and the \Sampler\ class used for performance measurement. It also defines the interface for \GCCounter\#count\_objects\.

sig · high confidence

This change introduces RBS type definitions for the core classes within the \sig/steep/subtyping\ directory, including \Cache\, \Check\, \Constraints\, \Relation\, \Result\, \Stats\, and \VariableVariance\. By adding these signatures, the subtyping engine's internal structures and methods are now explicitly typed, enabling static type checking for the subtyping logic itself and improving code clarity for developers working on type inference.

sig/steep/subtyping · high confidence

A new executable script at exe/steep has been added to allow users to run the Steep type checker directly from the command line. The script sets up the load path, requires the core steep and CLI modules, and invokes the Steep::CLI runner, ensuring that any unhandled exceptions result in a non-zero exit status (2) and print diagnostic information to stderr.

exe · high confidence

A new sample Steepfile has been added to the project that demonstrates how to configure code diagnostics for the :lib target. It shows how to specify signature and check paths, and includes commented-out examples for setting diagnostic levels (strict, lenient, silent) or customizing specific diagnostic types like NoMethod.

sample · high confidence

The \sig/steep/drivers\ directory now includes RBS type signatures for the core driver classes (such as \Check\, \Query\, \Langserver\, \Stats\, and \Watch\). This provides static type checking for the command-line interface and language server components, ensuring that method arguments, return types, and internal state are correctly defined across the driver layer.

sig/steep/drivers · high confidence

Added RBS type signature files for the parser shim, defining interfaces and classes for AST nodes (such as blocks, definitions, and conditionals), source maps, and source ranges to improve type checking and IDE support.

sig/shims/parser · high confidence

New RBS signature files have been added to the sample/sig directory to demonstrate various type-checking scenarios. These include conference.rbs for basic class and type definitions, deprecated.rbs for illustrating deprecation annotations, generics.rbs for generic type constraints and interfaces, and length.rbs for comparing untyped, subtyping, and generic method signatures.

sample/sig · high confidence

Added RBS type definition files for the core components of the type inference engine, including \BlockParams\, \CaseWhen\, \ConstantEnv\, \Context\, \LogicTypeInterpreter\, \MethodCall\, \MethodParams\, \MultipleAssignment\, \SendArgs\, \TypeEnv\, and \TypeEnvBuilder\. These signatures formally document the interfaces and data structures used for block parameter handling, case-when pattern matching, constant resolution, context management, logical type interpretation, method call analysis, multiple assignment expansion, argument sending, and type environment construction.

_sig/steep/type\inference · high confidence

The hover provider has been extended to display type information for RBS inline type declarations within Ruby source files. This change introduces new content classes (such as TypeAssertionContent) and logic in the Ruby provider to detect and resolve types for inline assertions, allowing users to see detailed type information when hovering over these constructs in addition to standard Ruby variables, methods, and constants.

_lib/steep/services/hover\provider · high confidence

Added RBS type definition files for the \Steep::Interface\ module, including \Block\, \Builder\, \Function\, \MethodType\, \Shape\, \Substitution\, and \TypeParam\. These signatures formally define the public API, attributes, and methods for the interface builder and shape resolution components, enabling static type checking of the interface layer.

sig/steep/interface · high confidence

The \lib/steep\ library now includes a persistent daemon server (\Steep::Daemon\) that maintains a long-running type-checking environment, allowing commands like \steep check\ and \steep query\ to connect via a Unix socket for faster performance. Additionally, a new \GitHubActionsFormatter\ has been added to the diagnostic printer, enabling type-checking errors to be formatted as native GitHub Actions workflow commands for better CI integration.

lib/steep · high confidence

The \lib/steep/services\ directory now contains a new set of specialized service classes that centralize and improve the type-checking and LSP capabilities. \TypeCheckService\ manages the validation of Ruby source files and RBS signatures, handling incremental updates and reporting diagnostics such as syntax errors and redundant ignore comments. \SignatureService\ (renamed from \SignatureController\) orchestrates the RBS environment, including graceful handling of library RBS syntax errors. \CompletionProvider\ and \SignatureHelpProvider\ deliver enhanced code completion (supporting keyword arguments, constants, and optional chaining) and signature help (indicating the active parameter). Additional services like \FileLoader\, \PathAssignment\, and \StatsCalculator\ support efficient file loading, distributed processing, and type coverage statistics.

lib/steep/services · high confidence

This change adds a new daemon server component that maintains a persistent RBS environment, enabling faster subsequent type-checking operations. The daemon communicates with clients using LSP JSON-RPC over Unix sockets, handling requests such as type checking and file change synchronization. The implementation includes a configuration module for managing paths and settings, and a server orchestrator that manages file tracking, background watching, and warm-up type-checking to ensure quick response times for client queries.

sig/steep/daemon · high confidence

The type system in lib/steep/ast/types has been expanded with new classes representing core types such as Any, Boolean, Bot, Class, Instance, Nil, Self, Top, Void, Var, and Logic, alongside composite types like Union, Intersection, Tuple, Record, and Proc. A new Factory class is introduced to translate RBS types into these internal AST representations and vice versa, enabling support for features like boolean types, literal types, and proc types with block bindings.

lib/steep/ast/types · high confidence

Steep now includes a new daemon server that maintains a persistent RBS environment, allowing clients to connect via a Unix socket using LSP JSON-RPC for communication. This change introduces a configuration system for managing socket and log paths, a file tracker to monitor project file changes, and a server implementation that manages type-checking workers and handles client interactions. The daemon supports a 'warm-up' phase to pre-load signatures for faster subsequent checks and includes security measures such as socket permission restrictions and symlink attack prevention.

lib/steep/daemon · high confidence

A new Validator class has been added to the signature module to enforce correctness in RBS type definitions. This change introduces runtime checks for type applications, ensuring that generic type arguments satisfy their upper bound constraints, and validates deprecated type names. It also supports recursive validation of ancestors and instance variable types, providing users with detailed diagnostic errors when their type signatures violate these structural rules.

lib/steep/signature · high confidence

The \lib/steep/ast/annotation/collection.rb\ file introduces a new \Steep::AST::Annotation::Collection\ class that aggregates and organizes various type annotations (such as variable, method, block, return, and dynamic annotations) within a specific context. This class provides methods to retrieve absolute types for local variables, instance variables, constants, methods, blocks, returns, self, instance, module, and break statements, as well as extracting dynamic instance and module method names. It also supports merging block annotations and iterating over the collected annotations, serving as a central structure for handling annotation data in the AST.

lib/steep/ast/annotation · high confidence

This change introduces several new driver classes that enable new \steep\ subcommands. The \Annotations\ driver adds a way to list inline type annotations in source files. The \PrintProject\ driver allows users to inspect the loaded project configuration and file mappings as JSON. The \Query\ driver enables querying the running daemon for hover information, definitions, and diagnostics. Additionally, \StartServer\ and \StopServer\ drivers provide explicit control over the background daemon process, while \Vendor\ is marked as deprecated in favor of \rbs vendor\.

lib/steep/drivers · high confidence

This release adds a suite of new command-line tools and scripts to the bin/ directory to support development, performance analysis, and testing workflows. It introduces \bin/rbs\ and \bin/rbs-inline\ to execute RBS tools using the project's specific \gemfile\_steep\ and collection configuration, ensuring consistent environments. For performance profiling, it adds \bin/steep-prof\ for in-process StackProf execution, \bin/steep-check\ for single-process type checking with support for various profilers (Vernier, memory\_profiler, StackProf), and several benchmarking scripts (\bin/shape\_warmup\_bench.rb\, \bin/subtyping\_cache\_bench.rb\, \bin/typecheck\_bench.rb\) to measure boot costs, subtyping cache efficiency, and type-checking performance. Memory analysis is supported by \bin/mem\_prof.rb\ and \bin/mem\_graph.rb\. Testing workflows are enhanced with \bin/output\_test.rb\ for running smoke tests with expectation files and \bin/output\_rebaseline.rb\ for updating those expectations. Additionally, \bin/generate-diagnostics-docs.rb\ automates the generation of documentation for Ruby code diagnostics from RBS signatures, and \bin/setup\ is updated to install the RBS collection.

bin · high confidence

Added a new \Steep::Source::IgnoreRanges\ class that parses and manages ignore comments within source files. This component tracks ignored lines and ranges, validates the structure of ignore directives (detecting errors like nested starts or unmatched ends), and provides methods to determine if specific code segments should be ignored based on their line numbers and diagnostic codes.

lib/steep/source · high confidence

This change introduces new indexing components within the \lib/steep/index\ directory to support enhanced symbol navigation. The new \RBSIndex\ class provides a structured index for RBS type signatures, tracking declarations and references for types, methods, constants, and globals, including support for RBS 3.0 features like \ClassModuleAliasDecl\. Complementing this, the \SourceIndex\ class indexes Ruby source code definitions and references for constants and methods, supporting incremental updates via child/parent merging. These indexes feed into the new \SignatureSymbolProvider\, which implements the LSP \workspace/symbol\ request, allowing users to search for and locate symbols (classes, modules, methods, properties, constants, and variables) across both RBS signature files and Ruby source files within the project.

lib/steep/index · high confidence

Steep 2.1.0 introduces significant improvements for tooling integration and modern Ruby support. The language server now binds a per-project UNIX socket, allowing \steep check\ and \steep query\ to connect to the existing editor server instead of starting separate daemons, which speeds up feedback for tools editing files on disk. A new \steep query diagnostics\ command reads pre-computed diagnostics from the server. The type checker now supports Ruby 3.4's \it\ block parameter and updates the RBS dependency to version 4.2.0. Additionally, the release includes fixes for tuple type inference, lambda block parameters, and various command-line tool behaviors.

(repo-wide) · high confidence

The type checker now allows using \\# @type self:\ annotations in top-level Ruby files to explicitly define the type of the implicit self object. This enables static analysis of methods like \succ\, \to\_s\, and \each\_line\ when invoked at the top level, treating the file's context as an instance of the specified type (e.g., String).

_smoke/toplevel\annotations · high confidence

Steep now parses and validates RBS type annotations embedded in Ruby source code, specifically supporting type assertions (e.g., \:ClassName\) and type applications (e.g., \$ClassName\[TypeArg\]\). New AST node classes, \TypeAssertion\ and \TypeApplication\, handle the parsing of these syntaxes and resolve type names using the RBS environment. The implementation includes validation logic to ensure the referenced types are valid within the current context, returning specific errors if the type syntax is invalid or the type cannot be resolved.

lib/steep/ast/node · high confidence

The \sig/steep/diagnostic\ directory now includes complete RBS type definitions for the diagnostic system, covering Ruby code diagnostics (e.g., \IncompatibleAssignment\, \UnexpectedPositionalArgument\), signature validation errors (e.g., \SyntaxError\, \DuplicatedDeclaration\), and formatting utilities (\LSPFormatter\, \ResultPrinter2\). This adds static type safety to the diagnostic classes, ensuring that diagnostic structures like error codes, locations, and messages are correctly typed across the type-checking engine.

sig/steep/diagnostic · high confidence

The server now runs as a master process coordinating multiple background workers, enabling concurrent type checking and interaction handling. This change introduces a set of custom LSP methods (prefixed with \$/steep/\) for internal communication, including type checking, diagnostics querying, and definition lookups. A new command socket allows CLI tools like \steep check\ and \steep query\ to communicate with the running language server instance instead of spawning separate processes. The master maintains a type check database and handles file change buffering, while workers process hover, completion, and signature help requests asynchronously.

lib/steep/server · high confidence

The monolithic completion provider has been split into distinct \CompletionProvider::RBS\ and \CompletionProvider::Ruby\ classes to separate type signature completion from Ruby code completion. The new \RBS\ provider handles type name resolution within RBS files, while the \Ruby\ provider manages completion for Ruby source code, including specific support for generating completion items within comments (such as \steep:ignore\ and \@type\ annotations). A dedicated \TypeName\ helper class was also introduced to manage prefix parsing and type name resolution logic shared across providers.

_lib/steep/services/completion\provider · high confidence

The hover provider service now includes formal RBS type definitions for its internal content classes (such as VariableContent, MethodCallContent, and ConstantContent) and its main service classes (Ruby and RBS). This adds static type checking to the hover functionality, ensuring that the data returned for code completions and documentation popups is correctly typed according to the Steep and RBS type systems.

_sig/steep/services/hover\provider · high confidence

This change introduces Steep type signatures for the internal indexing components that power workspace symbol lookups. It defines the \RBSIndex\ class (along with its \Builder\) to track type, method, constant, and global declarations and references from RBS environments, and adds \SignatureSymbolProvider\ to expose these symbols via the LSP \query\_symbol\ interface. A \SourceIndex\ signature is also added to track Ruby source-level definitions and references. These signatures formalize the data structures used to aggregate and query symbol information for inline declarations.

sig/steep/index · high confidence

The completion provider logic has been split into dedicated classes for RBS and Ruby contexts. The new \CompletionProvider::RBS\ class handles completion within RBS signature files, while \CompletionProvider::Ruby\ manages completions in Ruby source code, including support for completions inside comments. This separation clarifies the responsibilities of the completion engine and introduces specific handling for type names and context-aware suggestions in both file types.

_sig/steep/services/completion\provider · high confidence

The type-checking engine now uses a new set of internal classes to represent method signatures and type relationships. This includes \Interface::Block\ for handling block and proc types with self-type binding, \Interface::Function\ and its \Params\ structure for defining method parameters, \Interface::MethodType\ for representing method signatures with type parameters and blocks, \Interface::Shape\ for modeling the interface of objects (including method overloads and entries), and \Interface::Substitution\ for managing type variable replacements. These components form the foundation for the updated interface building and type checking logic.

lib/steep/interface · high confidence

The library has been significantly reorganized into a modular architecture, introducing dedicated services for type checking, signatures, and file loading, alongside new server components like a master-worker model and daemon support. The underlying parser has been upgraded to support Ruby 3.3 via the Prism parser, replacing previous versions, and the codebase now relies on the \concurrent-ruby\ gem for parallelism instead of forking. Users benefit from improved performance, better Ruby 3.3 syntax support, and new CLI commands for watching files, querying hover information, and managing the language server daemon.

lib · high confidence

The Steep signature validation logic has been refactored to use a new \Validator\ class that validates RBS declarations against the RBS 3.0 specification. This change introduces context-aware validation, tracking \self\_type\, \class\_type\, and \instance\_type\ to ensure type parameters and defaults are validated correctly within their specific scopes. It also adds diagnostics for deprecated type names and fixes previous issues where unexpected errors were reported or incorrect instance/class types were used during validation.

sig/steep/signature · high confidence

This change introduces two new utility modules in the driver layer: \DriverHelper\ and \JobsOption\. \DriverHelper\ centralizes configuration loading logic, automatically scaffolding a default project if no Steepfile is found, and handles RBS collection setup by installing missing collections or reporting specific errors (missing config, broken lockfile, etc.). It also provides utilities for LSP communication, including request/response waiting, shutdown handling, and diagnostic filtering based on severity levels. \JobsOption\ manages parallel processing counts, defaulting to the number of physical processors via \concurrent-ruby\ and ensuring at least one worker runs. These utilities support the broader driver infrastructure by standardizing config resolution, dependency installation, and concurrency control.

lib/steep/drivers/utils · high confidence

Steep introduces a new \Project\ DSL (lib/steep/project/dsl.rb) that allows users to define targets with specific source, signature, and inline source patterns, as well as library and RBS collection configurations. This change adds a \Target\ class (lib/steep/project/target.rb) that manages these patterns and constructs environment loaders, enabling more granular control over which files are type-checked and how RBS libraries are resolved. The new \Pattern\ class (lib/steep/project/pattern.rb) handles file matching logic, supporting ignore patterns and extensions, while \Group\ (lib/steep/project/group.rb) allows grouping files within a target. This refactors the previous flat configuration model into a more flexible target-based structure.

lib/steep/project · high confidence

The \lib/steep/subtyping\ directory has been replaced with a new implementation that introduces a dedicated subtyping cache (\Cache\) to store and retrieve type relation results, significantly improving performance for repeated checks. The engine now uses a \Constraints\ system to manage type variable bounds and solve inference problems, and a \Relation\ class to represent subtyping checks. A new \Stats\ module provides detailed metrics on cache hits, misses, and computation times, while \VariableVariance\ handles covariance and contravariance analysis. This change fundamentally alters how type compatibility is verified, moving from the previous logic to a more structured, cached, and constraint-aware approach.

lib/steep/subtyping · high confidence

The server now uses a master-worker architecture where the master process manages a TypeCheckDatabase, handles file changes via ChangeBuffer, and coordinates type-checking jobs to worker processes. This introduces several custom LSP methods: $/steep/typecheck/file for file-level type checking, $/steep/source/symbol for symbol resolution, $/steep/query/definition for definition lookups, $/steep/stats for type-checking statistics, and $/steep/groups for target group management. The master also exposes a CommandSocket for CLI tools to communicate with the running language server, and supports inline RBS declarations through InlineSourceChangeDetector.

sig/steep/server · high confidence

The AST module has been restructured to improve type safety and annotation parsing. Annotation types are now explicitly defined classes (e.g., Named, Typed, Dynamic) with clear location tracking, replacing previous implicit structures. Builtin types now use RBS::TypeName for consistent type name handling and include helper methods for constructing common types like nil, any, and optional. The ignore mechanism has been rewritten to use a dedicated BufferScanner for parsing steep:ignore comments, supporting start/end blocks and specific diagnostic filtering with improved robustness against line ending variations.

lib/steep/ast · high confidence

The diagnostic reporting infrastructure has been restructured to support Language Server Protocol (LSP) integration and configurable severity levels. A new \LSPFormatter\ class now converts diagnostics into LSP-compatible JSON, including support for diagnostic tags (such as \DEPRECATED\) and configurable severities (error, warning, information, hint) via a configuration hash. Deprecated diagnostic classes like \ElseOnExhaustiveCase\ and \UnknownConstantAssigned\ have been moved to a \deprecated\ subdirectory and now emit logger warnings directing users to their replacements (\UnreachableBranch\ and \UnknownConstant\). Additionally, helper modules (\Helper\, \ResultPrinter2\) and base classes for Ruby and Signature diagnostics have been introduced to standardize error message formatting and location handling.

lib/steep/diagnostic · high confidence

The type inference engine has been refactored to use a new set of dedicated classes for managing state and logic. This includes a new \Context\ class to centralize method, block, and module state, a \TypeEnv\ class to manage variable and constant types, and a \LogicTypeInterpreter\ to handle flow-sensitive type narrowing. Additionally, new classes \BlockParams\, \MethodParams\, \SendArgs\, \CaseWhen\, \MultipleAssignment\, and \ConstantEnv\ have been introduced to handle specific syntax and argument typing more robustly.

_lib/steep/type\inference · high confidence

The sample library has been updated to align with RBS 3.0 standards, introducing new example files that demonstrate modern Ruby type-checking features. The \inline.rb\ sample showcases inline RBS type declarations for methods and instance variables, while \deprecated.rb\ illustrates the use of \steep:ignore\ directives and deprecated code patterns. Additional samples like \conference.rb\ and \length.rb\ provide further examples of class structures, type annotations, and method usage within the updated framework.

sample/lib · high confidence

The type checker now correctly narrows union types within else branches. Previously, code that relied on narrowing a union type (e.g., from \Result \| :some\_symbol\ to \Result\) after an equality check in an if-else structure might have failed or produced incorrect diagnostics. This fix ensures that the type system accurately reflects the narrowed type in the else block, allowing valid code patterns to pass type checking.

smoke/narrowing-else · high confidence

Add smoke test for @implements annotation behavior; Add smoke test for Array\#map type inference; Add smoke test for Kernel\#Integer type checking; Add smoke test for TSort type inference; Add smoke test for case expression type checking; Add smoke test for initialize method handling; Add smoke test for interface and dynamic method handling; Add smoke test for interface method and assignment type checking; Add smoke test for keyword begin type checking; Add smoke test for lambda type checking; Add smoke test for rescue block type inference; Add smoke test for self-typing behavior; Add smoke test for skipping type checking; Add smoke test for stdout output verification; Add smoke test for string interpolation type checking; Add smoke test for super method typing and diagnostics; Add smoke test for top-level method type mismatch diagnostics; Add smoke test for type checking in \ensure\ blocks; Add smoke test for unknown type name diagnostics; Add smoke test for yield block type checking; Add smoke tests for RBS signature diagnostics; Add smoke tests for block typing and type inference; Add smoke tests for extension-based type checking; Add smoke tests for type alias resolution and checking; Add type signatures for DriverHelper and JobsOption utilities; Added RBS signatures for the test suite; Added RBS type signatures for completion provider tests; Added RBS type signatures for server test suites; Added smoke regression tests for type checking edge cases; Added smoke test for Array\#compact type inference; Added smoke test for Enumerator type inference constraints; Added smoke test for block\_given? type narrowing; Added smoke test for method type checking; Added smoke tests for Regexp and MatchData type checking; Added tests for AST ignore parsing and node type handling; Added tests for Ruby completion provider and type name resolution; Added tests for annotation collection, parsing, and type inference components; Added tests for server-side type checking and navigation components; Added tests for source ignore ranges; Added tests for the CLI checkfile command; Expanded smoke tests for Ruby type-checking diagnostics; Module type-checking smoke tests added; Smoke test for RBS duplicated declaration diagnostics; Smoke test for if-expression type inference and assignment compatibility; Smoke test for literal type checking; Smoke test for type-case narrowing and literal matching; Smoke test suite for constant type checking; Smoke tests added for Array type checking behavior; Smoke tests for class method signature compatibility and typing rules; Smoke tests for hash literal and record type checking; Support for && operator typing with nil handling.

The Steep gem has been updated to version 2.1.0, requiring Ruby 3.3.0 or later. The dependency list has been significantly expanded and tightened: it now explicitly depends on \rbs\ (\~\> 4.2), \prism\ (\>= 0.25.0), \parser\ (\>= 3.2), \concurrent-ruby\ (\>= 1.1.10), and several standard library gems (\json\, \csv\, \strscan\, \uri\, \securerandom\, \fileutils\, \logger\). Development dependencies for testing (\minitest\, \rake\) and profiling (\stackprof\, \vernier\, \memory\_profiler\) are now explicitly declared in the Gemfile. Additionally, the gemspec metadata has been populated with summary, description, homepage, license (MIT), and URI links, and the file inclusion logic has been updated to exclude test, spec, and configuration directories.

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

• Code Health 77
• Architecture 98
• Maturity 64
• Readiness 73
• Security 62

• 300 commits — 263 feature/other, 37 fixes

• (repo) — 113 commits
• lib/steep — 88 commits
• (root) — 37 commits
• .github/workflows — 13 commits
• gemfile_steep/Gemfile.lock — 12 commits
• sig/test — 12 commits
• sig/steep — 6 commits
• gemfile_steep/Gemfile — 2 commits
• test/test_helper.rb — 2 commits
• test/type_check_test.rb — 2 commits
• .github/dependabot.yml — 1 commit
• bin/shape_warmup_bench.rb — 1 commit
• bin/steep-check.rb — 1 commit
• bin/subtyping_cache_bench.rb — 1 commit
• bin/typecheck_bench.rb — 1 commit
• doc/release.md — 1 commit
• manual/ruby-diagnostics.md — 1 commit
• sig/shims — 1 commit
• smoke/block_given — 1 commit
• smoke/narrowing-else — 1 commit

• fix: Add regression tests for pair interface hints on array literals
• fix: Fix "assigned but unused variable" warnings
• fix: Fix "method redefined" warning in TypeCheckWorker
• fix: Fix "mismatched indentations" warnings
• fix: Fix Applying#map_type to use the mapped type arguments
• fix: Fix LSP completion and signature help for inline source files
• fix: Fix Literal#hash to depend on the value
• fix: Fix UnreachableBranch on == against literal supertype
• fix: Fix Gemfile
• fix: Fix bin/steep-check.rb for the current API
• fix: Fix log_output type error
• fix: Fix steep check with inline source paths
• fix: Fix array literal type inference with union tuple hint
• fix: Fix deprecation warning for Prism::Translation::Parser::Builder
• fix: Fix goto-definition in inline source files
• fix: Fix literal type hints to unwrap nil
• fix: Fix rbs collection setup
• fix: Fix silent false positive when conflicting RBS signatures cause AncestorErrorStatus (#2176)
• fix: Fix type error
• fix: Fix type errors
• …and 280 more

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

soutaro/steep 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.