steep 1.10.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3b79359121b2e5d63dcd89f96cb6e3a8851880701c965a23ecd29edafd047c5c
-  data.tar.gz: 17437149e2093895ba8826563aac4529b5efb8e41ae7752bba3df59fb2bffe93
+  metadata.gz: 0c7bef651d95df5415538e6d1a288b29395b2e49bdbabe20f3a79c51669760f7
+  data.tar.gz: a60d0fddf36b2e962d8c02802ab9f24424a2a428b07e63b5eb6c40c744fc0e71
 SHA512:
-  metadata.gz: 561a0bb7a9fa92840562f2bd1c30a9530e5bfcfdb5f20a42602c956876eb87486bf1f25938bbba9b081f3a2a7fca32dc85831b7f2912c0c9c4f4ae65fdb83075
-  data.tar.gz: 52bb1321df0464bf4bbe18416c7b6476da00338a2cee6aa2994a0d352102027275f5fbf4bc4a29e8319b97ae8b888227cd161a0606f06c4837d14c504f4b6b48
+  metadata.gz: 66f4985fee2186d7e9a4166b8a54f34272c3d156df4fc315d56ae4246361ba7fb44a77ebd8cf0f85860abe4bc75f5b5be5fad3c36a6183be2a4060cdbdacbc7a
+  data.tar.gz: ccf6e2b72945cb200fe448532887750f1b89e08a8ad3926cdc50711164aced9fb9fec693a0981825d604592889f46f3cb4bc94e8c23e437e368955e5187c4c8d

data/CHANGELOG.md

@@ -1,6 +1,89 @@
 # CHANGELOG
 
-## 3.10.0 (2025-03-18)
+## 2.0.0 (2026-04-14)
+
+### Summary
+
+Steep 2.0 introduces three major new features.
+
+* **Inline RBS Declaration (Experimental)**: Files configured with `check(inline: true)` can now have RBS type declarations written directly in Ruby code. Supports method types, `attr_*`, instance variables, constants, mixins, inheritance, and more, with editor integration for completion, hover, and go-to-definition.
+* **`steep server` command**: A daemon server that persists the RBS environment. By connecting to the daemon during `steep check`, it skips RBS environment setup and speeds up type checking.
+* **`steep query` command**: Query type information from the daemon server. `steep query hover` retrieves hover information and `steep query definition` retrieves definition locations, making type information accessible outside of editors.
+
+In addition, this release includes many improvements such as type narrowing for `block_given?`, type checking arbitrary expressions with the `steep check` with `-e` option, and Prism parser introduction for Ruby 3.4+.
+
+### Type checker core
+
+* Handle RBS library syntax error
+ ([#2211](https://github.com/soutaro/steep/pull/2211))
+* Fix literal type hints to unwrap nil ([#2205](https://github.com/soutaro/steep/pull/2205))
+* Fix array literal type inference with union tuple hint ([#2096](https://github.com/soutaro/steep/pull/2096))
+* Fix union narrowing in the else branch ([#2101](https://github.com/soutaro/steep/pull/2101))
+* feat: type narrowing for block_given? ([#2186](https://github.com/soutaro/steep/pull/2186))
+* Support @type var annotations in ensure blocks to suppress type errors ([#2194](https://github.com/soutaro/steep/pull/2194))
+* Fix ancestor error diagnostics reporting in library RBS files ([#2198](https://github.com/soutaro/steep/pull/2198))
+* Allow yield in methods with untyped parameters ([#2193](https://github.com/soutaro/steep/pull/2193))
+* Prepare for Ruby 3.4+ syntax support by introducing Prism parser ([#1845](https://github.com/soutaro/steep/pull/1845))
+* Trigger full type checking when type signature of inline RBS declaration is changed ([#1829](https://github.com/soutaro/steep/pull/1829))
+* Support inline class/module alias declaration ([#1819](https://github.com/soutaro/steep/pull/1819))
+* Fix `Locator::Inline` ([#1815](https://github.com/soutaro/steep/pull/1815))
+* Support inline constant declaration ([#1814](https://github.com/soutaro/steep/pull/1814))
+* Support instance variable declaration ([#1812](https://github.com/soutaro/steep/pull/1812))
+* Support inheritance ([#1809](https://github.com/soutaro/steep/pull/1809))
+* `attr_***` Inline RBS type declaration ([#1800](https://github.com/soutaro/steep/pull/1800))
+* Implement inline mixin ([#1788](https://github.com/soutaro/steep/pull/1788))
+* Provide workspace symbols feature for inline declarations ([#1741](https://github.com/soutaro/steep/pull/1741))
+* Fix splat/kwsplat param typing without name ([#1731](https://github.com/soutaro/steep/pull/1731))
+* Fix empty comment error ([#1730](https://github.com/soutaro/steep/pull/1730))
+* Type check service supports inline type declarations ([#1728](https://github.com/soutaro/steep/pull/1728))
+* Fix redundant ignore comment ([#1722](https://github.com/soutaro/steep/pull/1722))
+* Add `RedundantIgnoreComment` diagnostic ([#1670](https://github.com/soutaro/steep/pull/1670))
+* Update project and `Steepfile` DSL to support inline RBS declaration ([#1602](https://github.com/soutaro/steep/pull/1602))
+* Setup inline rbs integration ([#1585](https://github.com/soutaro/steep/pull/1585))
+
+### Commandline tool
+
+* Add `steep query definition NAME` command ([#2208](https://github.com/soutaro/steep/pull/2208))
+* Add `steep query hover` command for querying type info from daemon ([#2206](https://github.com/soutaro/steep/pull/2206))
+
+* Handle special characters in path when globbing ([#2203](https://github.com/soutaro/steep/pull/2203))
+* Add daemon server for persistent RBS environment ([#2080](https://github.com/soutaro/steep/pull/2080))
+* Fix `steep check` with inline source paths ([#2182](https://github.com/soutaro/steep/pull/2182))
+* Don't use `logger.fatal` for non-fatal info ([#2158](https://github.com/soutaro/steep/pull/2158))
+* Add -e flag to steep check for type checking arbitrary expressions ([#2102](https://github.com/soutaro/steep/pull/2102))
+
+### Language server
+
+* Fix goto-definition in inline source files ([#2192](https://github.com/soutaro/steep/pull/2192))
+* Support completion and signature help for inline type annotations ([#2191](https://github.com/soutaro/steep/pull/2191))
+* Implement completion for type names in inline RBS comments ([#1777](https://github.com/soutaro/steep/pull/1777))
+* Small bug fixes for goto inline definition ([#1775](https://github.com/soutaro/steep/pull/1775))
+* Goto definition into inline declaration ([#1774](https://github.com/soutaro/steep/pull/1774))
+* Implement goto definition from inline RBS types ([#1773](https://github.com/soutaro/steep/pull/1773))
+* Implement hover for Inline RBS types ([#1771](https://github.com/soutaro/steep/pull/1771))
+* Refactor hover content classes ([#1742](https://github.com/soutaro/steep/pull/1742))
+* Call `Process.warmup` before refork ([#1665](https://github.com/soutaro/steep/pull/1665))
+
+### Miscellaneous
+
+* Add RBS for test method ([#2204](https://github.com/soutaro/steep/pull/2204))
+* Add missing RBS definition for test_ensure_annotation ([#2202](https://github.com/soutaro/steep/pull/2202))
+* Add RBS signature generation and validation workflow ([#2200](https://github.com/soutaro/steep/pull/2200))
+* Fix rbs collection setup ([#2199](https://github.com/soutaro/steep/pull/2199))
+* Skip fork tests (2) ([#2196](https://github.com/soutaro/steep/pull/2196))
+* Fix test failure on Windows ([#2195](https://github.com/soutaro/steep/pull/2195))
+* Fix type checking ([#2181](https://github.com/soutaro/steep/pull/2181))
+* Remove activesupport dependency ([#2172](https://github.com/soutaro/steep/pull/2172))
+* bundle rbs-4.0.0 ([#2114](https://github.com/soutaro/steep/pull/2114))
+* Fix type errors ([#2170](https://github.com/soutaro/steep/pull/2170))
+* Remove unused `mutex_m` dependency ([#2106](https://github.com/soutaro/steep/pull/2106))
+* Use `rbs` gem from git repository ([#2068](https://github.com/soutaro/steep/pull/2068))
+* Fix typos ([#1572](https://github.com/soutaro/steep/pull/1572))
+* Let claude-code fix type errors ([#1709](https://github.com/soutaro/steep/pull/1709))
+* Drop Ruby 3.1 ([#1721](https://github.com/soutaro/steep/pull/1721))
+
+
+## 1.10.0 (2025-03-18)
 
 Nothing changed since `1.10.0.pre.3`.
 

data/CLAUDE.md

@@ -0,0 +1,114 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Overview
+
+Steep is a gradual type checker for Ruby that requires explicit type declarations using RBS (Ruby Signature) files. It performs static type checking without type inference and integrates with editors via Language Server Protocol.
+
+## Common Development Commands
+
+### Running Tests
+```bash
+# Run all unit tests
+rake test
+
+# Run smoke tests (integration tests with expected diagnostics)
+rake test:output
+
+# Run a specific test file
+ruby -Itest test/type_check_test.rb
+
+# Run current smoke test in a directory
+cd smoke/alias && rake test:output:current
+```
+
+### Type Checking
+```bash
+# Type check the Steep codebase itself
+bin/steep check
+
+# Type check with specific severity
+bin/steep check --severity=error
+
+# Watch mode for continuous type checking
+bin/steep watch
+
+# Start language server
+bin/steep langserver
+```
+
+### Building and Development
+```bash
+# Initial setup
+bin/setup
+
+# Generate RBS signatures from test files using rbs-inline
+rake rbs:generate
+
+# Watch and regenerate RBS signatures
+rake rbs:watch
+
+# Install gem locally
+bundle exec rake install
+
+# Build gem
+bundle exec rake build
+```
+
+## Architecture Overview
+
+### Core Type Checking Flow
+1. **Parser Phase**: Ruby code is parsed into AST using the parser gem
+2. **Type Construction**: `TypeConstruction` class builds typed AST by:
+   - Reading RBS signatures from sig/ directories
+   - Processing annotations (@type, @dynamic, etc.)
+   - Building type environments
+3. **Subtyping Check**: `Subtyping::Check` validates type relationships
+4. **Diagnostics**: Type errors are collected and formatted
+
+### Key Components
+
+**Type System Core** (`lib/steep/`):
+- `type_construction.rb`: Main type checking logic that traverses AST
+- `type_inference/`: Components for inferring types in specific contexts
+- `subtyping/`: Subtyping relationship validation
+- `interface/`: Type interface definitions and method resolution
+
+**Language Server** (`lib/steep/server/`):
+- `master.rb`: Coordinates worker processes
+- `type_check_worker.rb`: Performs type checking in background
+- `interaction_worker.rb`: Handles completion, hover, goto definition
+
+**Services** (`lib/steep/services/`):
+- `type_check_service.rb`: Manages incremental type checking
+- `signature_service.rb`: Manages RBS signatures and dependencies
+- `completion_provider.rb`: Provides code completion
+
+### Testing Strategy
+
+1. **Unit Tests**: Traditional tests in `test/` directory
+2. **Smoke Tests**: Integration tests in `smoke/` with:
+   - Each test case in its own directory
+   - `test_expectations.yml` defines expected diagnostics
+   - Tests cover Ruby features and edge cases
+
+### Configuration
+
+**Steepfile**: Defines type checking targets
+- `check`: Directories to type check
+- `signature`: RBS signature directories
+- `library`: Standard library dependencies
+- `collection_config`: External RBS definitions
+- Multiple targets supported (app, test, bin)
+
+**RBS Collection**: Manages external type definitions via `rbs_collection.steep.yaml`
+
+## Key Implementation Details
+
+- Self-hosted: Steep type-checks its own codebase
+- Uses RBS 4.0.0.dev (development version)
+- Requires Ruby 3.1.0+
+- Diagnostic severity levels: error, warning, information, hint
+- Supports gradual typing with @dynamic annotations
+- Implements LSP for IDE integration

data/README.md

@@ -203,7 +203,7 @@ Generally, these are by our design.
 
 ## Docs
 
-There are some documents in the `manul` and `guide` directories.
+There are some documents in the `manual` and `guides` directories.
 
 * [Guides](guides)
 * [Manual](manual)

data/Rakefile

@@ -19,6 +19,14 @@ namespace :test do
   task :output do
     sh "ruby", "bin/output_test.rb"
   end
+
+  namespace :output do
+    desc "Run current output test"
+    task :current do
+      puts ">> Running `steep check` in #{ENV["PWD"]}"
+      sh "steep", "check", "--with-expectations=test_expectations.yml", chdir: ENV["PWD"]
+    end
+  end
 end
 
 Rake::Task[:release].enhance do
@@ -232,7 +240,9 @@ namespace :rbs do
       paths = (modified + added).map do
         Pathname(_1).relative_path_from(Pathname.pwd)
       end
-      sh "rbs-inline", "--opt-out", "--output=sig", *paths.map(&:to_s)
+      Bundler.with_unbundled_env do
+        sh "bin/rbs-inline", "--opt-out", "--output=sig", *paths.map(&:to_s)
+      end
     end
     listener.start
     begin
@@ -243,7 +253,9 @@ namespace :rbs do
   end
 
   task :generate do
-    sh "rbs-inline --opt-out --output=sig test"
-    sh "rbs-inline --opt-out --output=tmp/rbs-inline bin/generate-diagnostics-docs.rb"
+    Bundler.with_unbundled_env do
+      sh "bin/rbs-inline --opt-out --output=sig test"
+      sh "bin/rbs-inline --opt-out --output=tmp/rbs-inline bin/generate-diagnostics-docs.rb"
+    end
   end
 end

data/Steepfile

@@ -5,14 +5,16 @@ D = Steep::Diagnostic
 FileUtils.mkpath("tmp")
 tmp_rbs_dir = Pathname("tmp/rbs-sig")
 
-definition = Bundler::Definition.build(Pathname("Gemfile"), Pathname("Gemfile.lock"), nil)
-rbs_dep = definition.dependencies.find {|dep| dep.name == "rbs" }
-if (source = rbs_dep&.source).is_a?(Bundler::Source::Path)
-  unless tmp_rbs_dir.directory?
-    FileUtils.ln_s(Pathname.pwd + source.path + "sig", tmp_rbs_dir.to_s, force: true)
+# The DSL is executed in the main process and worker processes, and the file operations introduce a race condition.
+# This line ensures the operations are executed only in the main process.
+if caller.none? {|c| c =~ /\/worker_process\.rb:/ }
+  tmp_rbs_dir.delete if tmp_rbs_dir.exist?
+
+  definition = Bundler::Definition.build(Pathname("Gemfile"), Pathname("Gemfile.lock"), nil)
+  rbs_dep = definition.dependencies.find {|dep| dep.name == "rbs" }
+  if (source = rbs_dep&.source).is_a?(Bundler::Source::Path)
+    tmp_rbs_dir.make_symlink(Pathname.pwd + source.path + "sig")
   end
-else
-  FileUtils.rm_f(tmp_rbs_dir)
 end
 
 target :app do
@@ -47,9 +49,7 @@ target :test do
 
   configure_code_diagnostics(D::Ruby.lenient)
 
-  if tmp_rbs_dir.directory?
-    signature tmp_rbs_dir.to_s
-  else
+  unless tmp_rbs_dir.directory?
     library "rbs"
   end
 end
@@ -63,9 +63,9 @@ target :bin do
   check "bin/generate-diagnostics-docs.rb"
   signature "tmp/rbs-inline/bin"
 
-  if tmp_rbs_dir.directory?
-    signature tmp_rbs_dir.to_s
-  else
+  configure_code_diagnostics(D::Ruby.lenient)
+  
+  unless tmp_rbs_dir.directory?
     library "rbs"
   end
 end

data/lib/steep/annotation_parser.rb

@@ -56,8 +56,12 @@ module Steep
           RBS::Parser.parse_type(string)
         rescue RBS::ParsingError => exn
           raise SyntaxError.new(source: string, location: loc, exn: exn)
-        end or raise
+        end
 
+      unless type
+        raise SyntaxError.new(source: string, location: loc, message: "Failed to parse a type in annotation")
+      end
+      
       unless (type.location || raise).source == string.strip
         raise SyntaxError.new(source: string, location: loc, message: "Failed to parse a type in annotation")
       end

data/lib/steep/annotations_helper.rb

@@ -21,9 +21,19 @@ module Steep
         when type_name.class?
           case
           when decl = env.class_decls.fetch(type_name, nil)
-            decl.decls.flat_map { _1.decl.annotations }
+            decl.each_decl.flat_map do |decl|
+              if decl.is_a?(RBS::AST::Declarations::Base)
+                decl.annotations
+              else
+                []
+              end
+            end
           when decl = env.class_alias_decls.fetch(type_name, nil)
-            decl.decl.annotations
+            if decl.decl.is_a?(RBS::AST::Declarations::Base)
+              decl.decl.annotations
+            else
+              [] #: Array[RBS::AST::Annotation]
+            end
           end
         when type_name.interface?
           if decl = env.interface_decls.fetch(type_name, nil)

data/lib/steep/ast/node/type_application.rb

@@ -25,33 +25,21 @@ module Steep
         end
 
         def types(context, subtyping, type_vars)
-          resolver = RBS::Resolver::TypeNameResolver.new(subtyping.factory.env)
-
           # @type var types: Array[LocatedValue[Types::t]]
           types = []
 
-          loc = type_location
-
-          while true
-            rbs_ty = RBS::Parser.parse_type(loc.buffer, range: loc.range, variables: type_vars) or break
-            rbs_loc = rbs_ty.location or raise
-            ty = rbs_ty.map_type_name {|name| resolver.resolve(name, context: context) || name.absolute! }
-
+          each_rbs_type(context, subtyping, type_vars) do |rbs_ty|
             validator = Signature::Validator.new(checker: subtyping)
             validator.rescue_validation_errors do
-              validator.validate_type(ty)
+              validator.validate_type(rbs_ty)
             end
 
             if validator.has_error?
               return validator.each_error
             end
 
-            ty = subtyping.factory.type(ty)
-            types << LocatedValue.new(value: ty, location: rbs_loc)
-
-            match = RBS::Location.new(loc.buffer, rbs_loc.end_pos, type_location.end_pos).source.match(/\A\s*,\s*/) or break
-            offset = match.length
-            loc = RBS::Location.new(loc.buffer, rbs_loc.end_pos + offset, type_location.end_pos)
+            ty = subtyping.factory.type(rbs_ty)
+            types << LocatedValue.new(value: ty, location: rbs_ty.location || raise)
           end
 
           types
@@ -68,6 +56,24 @@ module Steep
           end
         end
 
+        def each_rbs_type(context, subtyping, type_vars)
+          resolver = RBS::Resolver::TypeNameResolver.build(subtyping.factory.env)
+
+          loc = type_location
+
+          while true
+            type = RBS::Parser.parse_type(loc.buffer, range: loc.range, variables: type_vars) or break
+            type_loc = type.location or raise
+            type = type.map_type_name {|name| resolver.resolve(name, context: context) || name.absolute! }
+
+            yield type
+
+            match = RBS::Location.new(loc.buffer, type_loc.end_pos, type_location.end_pos).source.match(/\A\s*,\s*/) or break
+            offset = match.length
+            loc = RBS::Location.new(loc.buffer, type_loc.end_pos + offset, type_location.end_pos)
+          end
+        end
+
         def type_str
           @type_str ||= source.delete_prefix("$").lstrip
         end

data/lib/steep/ast/node/type_assertion.rb

@@ -16,11 +16,15 @@ module Steep
           location.start_line
         end
 
-        def type(context, subtyping, type_vars)
+        def rbs_type(context, subtyping, type_vars)
           if ty = RBS::Parser.parse_type(type_location.buffer, range: type_location.range, variables: type_vars, require_eof: true)
-            resolver = RBS::Resolver::TypeNameResolver.new(subtyping.factory.env)
+            resolver = RBS::Resolver::TypeNameResolver.build(subtyping.factory.env)
             ty = ty.map_type_name {|name| resolver.resolve(name, context: context) || name.absolute! }
+          end
+        end
 
+        def type(context, subtyping, type_vars)
+          if ty = rbs_type(context, subtyping, type_vars)
             validator = Signature::Validator.new(checker: subtyping)
             validator.rescue_validation_errors do
               validator.validate_type(ty)
@@ -40,9 +44,8 @@ module Steep
 
         def type_syntax?
           RBS::Parser.parse_type(type_location.buffer, range: type_location.range, variables: [], require_eof: true)
-          true
         rescue ::RBS::ParsingError
-          false
+          nil
         end
 
         def type?(context, subtyping, type_vars)

data/lib/steep/ast/types/factory.rb

@@ -21,7 +21,7 @@ module Steep
         end
 
         def type_name_resolver
-          @type_name_resolver ||= RBS::Resolver::TypeNameResolver.new(definition_builder.env)
+          @type_name_resolver ||= RBS::Resolver::TypeNameResolver.build(definition_builder.env)
         end
 
         def type_opt(type)
@@ -39,7 +39,7 @@ module Steep
         def normalize_args(type_name, args)
           case
           when type_name.class?
-            if entry = env.normalized_module_class_entry(type_name)
+            if entry = env.module_class_entry(type_name, normalized: true)
               type_params = entry.type_params
             end
           when type_name.interface?
@@ -294,6 +294,7 @@ module Steep
                 raise "`#{u_}` cannot be type parameter upper bound"
               end
             },
+            lower_bound: nil,
             location: type_param.location
           ).unchecked!(type_param.unchecked)
         end