steep-relaxed 1.9.4.3 → 2.0.0.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7a2375aaccd85c970192b3cdaec8db80d183c631673e6d6d9b12e77f1d8d9105
-  data.tar.gz: 559f9c8e17a214295d9908c4d56e7e514dc4f37725afab3cbfc551d91455d68e
+  metadata.gz: bf5a5feae44a03f61bc114e4e4fe1de58935bc27843fc9045d7346327a836094
+  data.tar.gz: d81ebcda41a90a75d91d46a977ca7c463c75930d89be38834d19be0ce782fea1
 SHA512:
-  metadata.gz: 3fcace45e6c372a8e445440295db3bec8336ae71235237110c0f37b64aff8db8094410c7849e146fdd890841ffee54416dd7996f2d237abec29a5b5bea143dd5
-  data.tar.gz: 7bb970fbaf54732f2bfdd64a6e495e86a07742001e9fb255c39f5386be9a2c0309c5c19f57cd6345487bacc905b85efea8ba0f411bbecf33ffcc95ef5b11b04c
+  metadata.gz: 841398130d2c8acc7b526cd9f5f6256fbbb384838761df34edaab396a622917604bcc53ba1c97e3203c1448946b1f4ef1d5b4ee53f0c406d89afb1417ef9f34a
+  data.tar.gz: 0e910c89be4bb2a820db10a634b0fedee8f413e4bc1436f69a602e19082bc030a43ea64b41e57bdfe2f381fb4861520079c8b1d024f8bd215c271c05aea95a1e

data/CHANGELOG.md

@@ -1,5 +1,148 @@
 # CHANGELOG
 
+## 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`.
+
+## 1.10.0.pre.3 (2025-03-14)
+
+### Type checker core
+
+* Fix block type checking ([#1534](https://github.com/soutaro/steep/pull/1534))
+
+## 1.10.0.pre.2 (2025-03-14)
+
+### Type checker core
+
+* Fix `self` type handling at block-self-hint ([#1531](https://github.com/soutaro/steep/pull/1531))
+* Delay type variable resolution on method call with blocks ([#1530](https://github.com/soutaro/steep/pull/1530))
+* Fix type checking block calls on `untyped` receiver ([#1528](https://github.com/soutaro/steep/pull/1528))
+* Catch the message of VariableDuplicationError ([#1521](https://github.com/soutaro/steep/pull/1521))
+
+## 1.10.0.pre.1 (2025-03-11)
+
+### Type checker core
+
+* Skip type checking forwarded argument if the method is undeclared ([#1519](https://github.com/soutaro/steep/pull/1519))
+* Dedup error message on ancestors check ([#1515](https://github.com/soutaro/steep/pull/1515))
+* Add deprecation validation on RBS ([#1518](https://github.com/soutaro/steep/pull/1518))
+* Fix union self type refinement based on method call ([#1517](https://github.com/soutaro/steep/pull/1517))
+* Check deprecations in Ruby code ([#1513](https://github.com/soutaro/steep/pull/1513))
+* Support `InvalidTypeApplication` on `#update_env` ([#1507](https://github.com/soutaro/steep/pull/1507))
+* Fix Source.parse crashes with selector-less sendish node ([#1433](https://github.com/soutaro/steep/pull/1433))
+* Fix steep:ignore does not work with CR/LF ([#1406](https://github.com/soutaro/steep/pull/1406))
+* Fix self union type checking ([#1467](https://github.com/soutaro/steep/pull/1467))
+* Type narrowing union types via return type of method call ([#1497](https://github.com/soutaro/steep/pull/1497))
+* Fix `else` clause of `case-when` syntax typing ([#1475](https://github.com/soutaro/steep/pull/1475))
+* Strict record and tuple subtyping ([#1460](https://github.com/soutaro/steep/pull/1460))
+* Allow to annotate "self" on toplevel ([#1455](https://github.com/soutaro/steep/pull/1455))
+* Let annotations in `when` clause without `cond` expression work ([#1459](https://github.com/soutaro/steep/pull/1459))
+* Fix `RuntimeError` on `when` clause with assertion ([#1458](https://github.com/soutaro/steep/pull/1458))
+* Add diagnostic for method definition without types ([#1457](https://github.com/soutaro/steep/pull/1457))
+
+### Commandline tool
+
+* Implement GitHub formatter ([#1516](https://github.com/soutaro/steep/pull/1516))
+* Refine `--help` messages ([#1463](https://github.com/soutaro/steep/pull/1463))
+
+### Language server
+
+* Reforking steep ([#1492](https://github.com/soutaro/steep/pull/1492))
+* Set up file watcher for groups ([#1485](https://github.com/soutaro/steep/pull/1485))
+
+### Miscellaneous
+
+* Fix a runtime warning for ambiguous `/`; wrap regexp in parentheses or add a space after `/` operator ([#1438](https://github.com/soutaro/steep/pull/1438))
+* Fix a runtime warning for ambiguous `*` has been interpreted as an argument prefix ([#1439](https://github.com/soutaro/steep/pull/1439))
+* Fix a runtime warning for key :cursor is duplicated and overwritten on line 99 ([#1440](https://github.com/soutaro/steep/pull/1440))
+* Use release version of RBS ([#1511](https://github.com/soutaro/steep/pull/1511))
+* Prepare for rbs-3.9 ([#1510](https://github.com/soutaro/steep/pull/1510))
+* Fix typos ([#1506](https://github.com/soutaro/steep/pull/1506))
+* Fix CI ([#1486](https://github.com/soutaro/steep/pull/1486))
+
 ## 1.9.3 (2024-12-26)
 
 ### Miscellaneous

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

@@ -208,7 +208,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
 
 # Disable the following task enhancement add upstream
@@ -225,3 +233,30 @@ NOTES
     end
   end
 end
+
+namespace :rbs do
+  task :watch do
+    require "listen"
+    listener = Listen.to('test') do |modified, added, removed|
+      paths = (modified + added).map do
+        Pathname(_1).relative_path_from(Pathname.pwd)
+      end
+      Bundler.with_unbundled_env do
+        sh "bin/rbs-inline", "--opt-out", "--output=sig", *paths.map(&:to_s)
+      end
+    end
+    listener.start
+    begin
+      sleep
+    rescue Interrupt
+      listener.stop
+    end
+  end
+
+  task :generate do
+    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,15 +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)
-  library "rbs"
 end
 
 target :app do
@@ -48,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
@@ -64,5 +63,9 @@ target :bin do
   check "bin/generate-diagnostics-docs.rb"
   signature "tmp/rbs-inline/bin"
 
-  library "rbs"
+  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

@@ -0,0 +1,53 @@
+module Steep
+  module AnnotationsHelper
+    module_function
+
+    def deprecated_annotation?(annotations)
+      annotations.reverse_each do |annotation|
+        if match = annotation.string.match(/deprecated(:\s*(?<message>.+))?/)
+          return [annotation, match[:message]]
+        end
+        if match = annotation.string.match(/steep:deprecated(:\s*(?<message>.+))?/)
+          return [annotation, match[:message]]
+        end
+      end
+
+      nil
+    end
+
+    def deprecated_type_name?(type_name, env)
+      annotations =
+        case
+        when type_name.class?
+          case
+          when decl = env.class_decls.fetch(type_name, nil)
+            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)
+            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)
+            decl.decl.annotations
+          end
+        when type_name.alias?
+          if decl = env.type_alias_decls.fetch(type_name, nil)
+            decl.decl.annotations
+          end
+        end
+
+      if annotations
+        deprecated_annotation?(annotations)
+      end
+    end
+  end
+end

data/lib/steep/ast/ignore.rb

@@ -93,15 +93,14 @@ module Steep
       def self.parse(comment, buffer)
         return unless comment.inline?
 
-        comment_location = RBS::Location.new(buffer, comment.loc.expression.begin_pos, comment.loc.expression.end_pos)
+        begin_pos = buffer.loc_to_pos([comment.loc.line, comment.loc.column])
+        end_pos = buffer.loc_to_pos([comment.loc.last_line, comment.loc.last_column])
+        comment_location = RBS::Location.new(buffer, begin_pos, end_pos)
         scanner = BufferScanner.new(comment_location)
 
         scanner.scan(/#/)
         scanner.skip(/\s*/)
 
-        begin_pos = comment.location.expression.begin_pos
-        end_pos = comment.location.expression.end_pos
-
         case
         when loc = scanner.scan(/steep:ignore:start\b/)
           scanner.skip(/\s*/)

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