steep 1.10.0.dev.1 → 1.10.0.pre.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c16f09c4999f414317b991d4c36ed5a5b51a2bf785d4f865ab9d698890050205
-  data.tar.gz: f0a34b2b9c27703a87375e19a33055bed47ae3cc1ac8dae4fc846a931e054223
+  metadata.gz: 8dd3b63cbd4f85f05eb3643505e5bff6c4a6d6a1384959c3a0660153030e9449
+  data.tar.gz: b4afe185ffc5f9e0907e97b2f6a60638b887dcecb8b8b57992d8a652b63d94f7
 SHA512:
-  metadata.gz: 24d081be36d7b8bd33ffe5786db94ff5e8a1b505c7dfa72e4076b3c7612d78e6c5978bebba991d792e9fc4b97bb0da3f004db308eade2b6ed6e63075ce3f9d9f
-  data.tar.gz: 68069586284621fac6acbc1f279a3b866b26dcba5436334f16abb6db3466c2917a549c0f2b48bfc205eab74ee3d865124ab1a87f7b02403bb2a8b39d2c67a938
+  metadata.gz: 2060d786b8adf7d3876f3168f3fea26e999f6f4445cf8c109032e73ddcb99f2e4483706a4aedd1a61a9eb480cb9f42bcaea941f41d9ea9f843b84bcfa7cef3da
+  data.tar.gz: 875d9870e9c6082b428636b9e70c9e794008feb35b25a040aa608893e70bac5021f5cd4f0d9b44064f07851c134b17a148377906df0e90c547cf8359b01e9972

data/CHANGELOG.md

@@ -1,5 +1,55 @@
 # CHANGELOG
 
+## 3.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/Rakefile

@@ -224,3 +224,26 @@ 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
+      sh "rbs-inline", "--opt-out", "--output=sig", *paths.map(&:to_s)
+    end
+    listener.start
+    begin
+      sleep
+    rescue Interrupt
+      listener.stop
+    end
+  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"
+  end
+end

data/lib/steep/annotations_helper.rb

@@ -14,5 +14,30 @@ module Steep
 
       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.decls.flat_map { _1.decl.annotations }
+          when decl = env.class_alias_decls.fetch(type_name, nil)
+            decl.decl.annotations
+          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/cli.rb

@@ -187,6 +187,10 @@ BANNER
             end
           end
 
+          opts.on("--format=FORMATTER", ["code", "github"], "Output formatters (default: code, options: code,github)") do |formatter|
+            command.formatter = formatter
+          end
+
           handle_jobs_option command.jobs_option, opts
           handle_logging_options opts
         end.parse!(argv)

data/lib/steep/diagnostic/lsp_formatter.rb

@@ -54,6 +54,9 @@ module Steep
           case diagnostic
           when Ruby::DeprecatedReference
             tags << LSP::Constant::DiagnosticTag::DEPRECATED
+          when Signature::DeprecatedTypeName
+            tags << LSP::Constant::DiagnosticTag::DEPRECATED
+            severity = LSP::Constant::DiagnosticSeverity::WARNING
           end
 
           json = {

data/lib/steep/diagnostic/signature.rb

@@ -273,6 +273,30 @@ module Steep
         end
       end
 
+      class VariableDuplicationError < Base
+        attr_reader :type_name
+        attr_reader :variable_name
+        attr_reader :location
+
+        def initialize(type_name:, variable_name:, location:)
+          @type_name = type_name
+          @variable_name = variable_name
+          @location = location
+        end
+      end
+
+      class InstanceVariableDuplicationError < VariableDuplicationError
+        def header_line
+          "Duplicated instance variable name `#{variable_name}` in `#{type_name}`"
+        end
+      end
+
+      class ClassInstanceVariableDuplicationError < VariableDuplicationError
+        def header_line
+          "Duplicated class instance variable name `#{variable_name}` in `#{type_name}`"
+        end
+      end
+
       class ClassVariableDuplicationError < Base
         attr_reader :class_name
         attr_reader :other_class_name
@@ -460,6 +484,26 @@ module Steep
         end
       end
 
+      class DeprecatedTypeName < Base
+        attr_reader :type_name
+        attr_reader :message
+
+        def initialize(type_name, message, location:)
+          super(location: location)
+          @type_name = type_name
+          @message = message
+        end
+
+        def header_line
+          buffer = "Type `#{type_name}` is deprecated"
+          if message
+            buffer = +buffer
+            buffer << ": " << message
+          end
+          buffer
+        end
+      end
+
 
       def self.from_rbs_error(error, factory:)
         case error
@@ -561,6 +605,10 @@ module Steep
           Diagnostic::Signature::CyclicClassAliasDefinitionError.new(decl: error.alias_entry.decl)
         when RBS::TypeParamDefaultReferenceError
           Diagnostic::Signature::TypeParamDefaultReferenceError.new(error.type_param, location: error.location)
+        when RBS::InstanceVariableDuplicationError
+          Diagnostic::Signature::InstanceVariableDuplicationError.new(type_name: error.type_name, variable_name: error.variable_name, location: error.location)
+        when RBS::ClassInstanceVariableDuplicationError
+          Diagnostic::Signature::ClassInstanceVariableDuplicationError.new(type_name: error.type_name, variable_name: error.variable_name, location: error.location)
         else
           raise error
         end

data/lib/steep/drivers/check.rb

@@ -16,6 +16,7 @@ module Steep
       attr_accessor :validate_group_signatures
       attr_accessor :validate_project_signatures
       attr_accessor :validate_library_signatures
+      attr_accessor :formatter
 
       include Utils::DriverHelper
 
@@ -30,6 +31,7 @@ module Steep
         @validate_group_signatures = true
         @validate_project_signatures = false
         @validate_library_signatures = false
+        @formatter = 'code'
       end
 
       def active_group?(group)
@@ -322,7 +324,7 @@ module Steep
           errors.each do |notification|
             path = Steep::PathHelper.to_pathname(notification[:uri]) or raise
             buffer = RBS::Buffer.new(name: project.relative_path(path), content: path.read)
-            printer = DiagnosticPrinter.new(buffer: buffer, stdout: stdout)
+            printer = DiagnosticPrinter.new(buffer: buffer, stdout: stdout, formatter: formatter)
 
             notification[:diagnostics].each do |diag|
               printer.print(diag)

data/lib/steep/drivers/diagnostic_printer/base_formatter.rb

@@ -0,0 +1,19 @@
+module Steep
+  module Drivers
+    class DiagnosticPrinter
+      class BaseFormatter
+        attr_reader :stdout
+        attr_reader :buffer
+
+        def initialize(stdout:, buffer:)
+          @stdout = stdout
+          @buffer = buffer
+        end
+
+        def path
+          Pathname(buffer.name)
+        end
+      end
+    end
+  end
+end

data/lib/steep/drivers/diagnostic_printer/code_formatter.rb

@@ -0,0 +1,95 @@
+module Steep
+  module Drivers
+    class DiagnosticPrinter
+      class CodeFormatter < BaseFormatter
+        def print(diagnostic, prefix: "", source: true)
+          header, *rest = diagnostic[:message].split(/\n/)
+
+          stdout.puts "#{prefix}#{location(diagnostic)}: [#{severity_message(diagnostic[:severity])}] #{Rainbow(header).underline}"
+
+          unless rest.empty?
+            rest.each do |message|
+              stdout.puts "#{prefix}│ #{message}"
+            end
+          end
+
+          if diagnostic[:code]
+            stdout.puts "#{prefix}│" unless rest.empty?
+            stdout.puts "#{prefix}│ Diagnostic ID: #{diagnostic[:code]}"
+          end
+
+          stdout.puts "#{prefix}│"
+
+          if source
+            print_source_line(diagnostic, prefix: prefix)
+          else
+            stdout.puts "#{prefix}└ (no source code available)"
+            stdout.puts "#{prefix}"
+          end
+        end
+
+        private
+
+        def color_severity(string, severity:)
+          s = Rainbow(string)
+
+          case severity
+          when LSP::Constant::DiagnosticSeverity::ERROR
+            s.red
+          when LSP::Constant::DiagnosticSeverity::WARNING
+            s.yellow
+          when LSP::Constant::DiagnosticSeverity::INFORMATION
+            s.blue
+          else
+            s
+          end
+        end
+
+        def severity_message(severity)
+          string = case severity
+                  when LSP::Constant::DiagnosticSeverity::ERROR
+                    "error"
+                  when LSP::Constant::DiagnosticSeverity::WARNING
+                    "warning"
+                  when LSP::Constant::DiagnosticSeverity::INFORMATION
+                    "information"
+                  when LSP::Constant::DiagnosticSeverity::HINT
+                    "hint"
+                  else
+                    raise
+                  end
+
+          color_severity(string, severity: severity)
+        end
+
+        def location(diagnostic)
+          start = diagnostic[:range][:start]
+          Rainbow("#{path}:#{start[:line]+1}:#{start[:character]}").magenta
+        end
+
+        def print_source_line(diagnostic, prefix: "")
+          start_pos = diagnostic[:range][:start]
+          end_pos = diagnostic[:range][:end]
+
+          line = buffer.lines.fetch(start_pos[:line])
+
+          leading = line[0...start_pos[:character]] || ""
+          if start_pos[:line] == end_pos[:line]
+            subject = line[start_pos[:character]...end_pos[:character]] || ""
+            trailing = (line[end_pos[:character]...] || "").chomp
+          else
+            subject = (line[start_pos[:character]...] || "").chomp
+            trailing = ""
+          end
+
+          unless subject.valid_encoding?
+            subject.scrub!
+          end
+
+          stdout.puts "#{prefix}└ #{leading}#{color_severity(subject, severity: diagnostic[:severity])}#{trailing}"
+          stdout.puts "#{prefix}  #{" " * leading.size}#{"~" * subject.size}"
+        end
+      end
+    end
+  end
+end

data/lib/steep/drivers/diagnostic_printer/github_actions_formatter.rb

@@ -0,0 +1,44 @@
+module Steep
+  module Drivers
+    class DiagnosticPrinter
+      # https://docs.github.com/en/actions/writing-workflows/choosing-what-your-workflow-does/workflow-commands-for-github-actions
+      class GitHubActionsFormatter < BaseFormatter
+        ESCAPE_MAP = { '%' => '%25', "\n" => '%0A', "\r" => '%0D' }.freeze
+
+        def print(diagnostic, prefix: "", source: true)
+          stdout.printf(
+            "::%<severity>s file=%<file>s,line=%<line>d,endLine=%<endLine>d,col=%<column>d,endColumn=%<endColumn>d::%<message>s",
+            severity: github_severity(diagnostic[:severity]),
+            file: path,
+            line: diagnostic[:range][:start][:line] + 1,
+            endLine: diagnostic[:range][:end][:line] + 1,
+            column: diagnostic[:range][:start][:character],
+            endColumn: diagnostic[:range][:end][:character],
+            message: github_escape("[#{diagnostic[:code]}] #{diagnostic[:message]}")
+          )
+        end
+
+        private
+
+        def github_severity(severity)
+          case severity
+          when LSP::Constant::DiagnosticSeverity::ERROR
+            "error"
+          when LSP::Constant::DiagnosticSeverity::WARNING
+            "warning"
+          when LSP::Constant::DiagnosticSeverity::INFORMATION
+            "notice"
+          when LSP::Constant::DiagnosticSeverity::HINT
+            "notice"
+          else
+            raise
+          end
+        end
+
+        def github_escape(string)
+          string.gsub(Regexp.union(ESCAPE_MAP.keys), ESCAPE_MAP)
+        end
+      end
+    end
+  end
+end

data/lib/steep/drivers/diagnostic_printer.rb

@@ -1,104 +1,27 @@
 module Steep
   module Drivers
     class DiagnosticPrinter
+
       LSP = LanguageServer::Protocol
 
       attr_reader :stdout
       attr_reader :buffer
 
-      def initialize(stdout:, buffer:)
+      def initialize(stdout:, buffer:, formatter: 'code')
         @stdout = stdout
         @buffer = buffer
-      end
-
-      def path
-        Pathname(buffer.name)
-      end
-
-      def color_severity(string, severity:)
-        s = Rainbow(string)
-
-        case severity
-        when LSP::Constant::DiagnosticSeverity::ERROR
-          s.red
-        when LSP::Constant::DiagnosticSeverity::WARNING
-          s.yellow
-        when LSP::Constant::DiagnosticSeverity::INFORMATION
-          s.blue
+        @formatter = case formatter
+        when 'code'
+          CodeFormatter.new(stdout: stdout, buffer: buffer)
+        when 'github'
+          GitHubActionsFormatter.new(stdout: stdout, buffer: buffer)
         else
-          s
+          raise "Unknown formatter: #{formatter}"
         end
       end
 
-      def severity_message(severity)
-        string = case severity
-                 when LSP::Constant::DiagnosticSeverity::ERROR
-                   "error"
-                 when LSP::Constant::DiagnosticSeverity::WARNING
-                   "warning"
-                 when LSP::Constant::DiagnosticSeverity::INFORMATION
-                   "information"
-                 when LSP::Constant::DiagnosticSeverity::HINT
-                   "hint"
-                 else
-                  raise
-                 end
-
-        color_severity(string, severity: severity)
-      end
-
-      def location(diagnostic)
-        start = diagnostic[:range][:start]
-        Rainbow("#{path}:#{start[:line]+1}:#{start[:character]}").magenta
-      end
-
       def print(diagnostic, prefix: "", source: true)
-        header, *rest = diagnostic[:message].split(/\n/)
-
-        stdout.puts "#{prefix}#{location(diagnostic)}: [#{severity_message(diagnostic[:severity])}] #{Rainbow(header).underline}"
-
-        unless rest.empty?
-          rest.each do |message|
-            stdout.puts "#{prefix}│ #{message}"
-          end
-        end
-
-        if diagnostic[:code]
-          stdout.puts "#{prefix}│" unless rest.empty?
-          stdout.puts "#{prefix}│ Diagnostic ID: #{diagnostic[:code]}"
-        end
-
-        stdout.puts "#{prefix}│"
-
-        if source
-          print_source_line(diagnostic, prefix: prefix)
-        else
-          stdout.puts "#{prefix}└ (no source code available)"
-          stdout.puts "#{prefix}"
-        end
-      end
-
-      def print_source_line(diagnostic, prefix: "")
-        start_pos = diagnostic[:range][:start]
-        end_pos = diagnostic[:range][:end]
-
-        line = buffer.lines.fetch(start_pos[:line])
-
-        leading = line[0...start_pos[:character]] || ""
-        if start_pos[:line] == end_pos[:line]
-          subject = line[start_pos[:character]...end_pos[:character]] || ""
-          trailing = (line[end_pos[:character]...] || "").chomp
-        else
-          subject = (line[start_pos[:character]...] || "").chomp
-          trailing = ""
-        end
-
-        unless subject.valid_encoding?
-          subject.scrub!
-        end
-
-        stdout.puts "#{prefix}└ #{leading}#{color_severity(subject, severity: diagnostic[:severity])}#{trailing}"
-        stdout.puts "#{prefix}  #{" " * leading.size}#{"~" * subject.size}"
+        @formatter.print(diagnostic, prefix: prefix, source: source)
       end
     end
   end

data/lib/steep/server/interaction_worker.rb

@@ -268,6 +268,11 @@ module Steep
 
         type_name = sig_service.latest_env.normalize_type_name(type_name)
 
+        tags = [] #: Array[LSP::Constant::CompletionItemTag::t]
+        if AnnotationsHelper.deprecated_type_name?(type_name, sig_service.latest_env)
+          tags << LSP::Constant::CompletionItemTag::DEPRECATED
+        end
+
         case type_name.kind
         when :class
           env = sig_service.latest_env
@@ -290,7 +295,8 @@ module Steep
               range: range,
               new_text: complete_text
             ),
-            kind: LSP::Constant::CompletionItemKind::CLASS
+            kind: LSP::Constant::CompletionItemKind::CLASS,
+            tags: tags
           )
         when :alias
           alias_decl = sig_service.latest_env.type_alias_decls[type_name]&.decl or raise
@@ -303,7 +309,8 @@ module Steep
               new_text: complete_text
             ),
             documentation: LSPFormatter.markup_content { LSPFormatter.format_rbs_completion_docs(type_name, alias_decl, [alias_decl.comment].compact) },
-            kind: LSP::Constant::CompletionItemKind::FIELD
+            kind: LSP::Constant::CompletionItemKind::FIELD,
+            tags: tags
           )
         when :interface
           interface_decl = sig_service.latest_env.interface_decls[type_name]&.decl or raise
@@ -316,7 +323,8 @@ module Steep
               new_text: complete_text
             ),
             documentation: LSPFormatter.markup_content { LSPFormatter.format_rbs_completion_docs(type_name, interface_decl, [interface_decl.comment].compact) },
-            kind: LSP::Constant::CompletionItemKind::INTERFACE
+            kind: LSP::Constant::CompletionItemKind::INTERFACE,
+            tags: tags
           )
         else
           raise
@@ -435,6 +443,12 @@ module Steep
             when item.absolute_type_name.alias?
               LSP::Constant::CompletionItemKind::FIELD
             end
+
+          tags = [] #: Array[LSP::Constant::CompletionItemTag::t]
+          if AnnotationsHelper.deprecated_type_name?(item.absolute_type_name, item.env)
+            tags << LSP::Constant::CompletionItemTag::DEPRECATED
+          end
+
           LSP::Interface::CompletionItem.new(
             label: item.relative_type_name.to_s,
             kind: kind,
@@ -443,7 +457,8 @@ module Steep
             text_edit: LSP::Interface::TextEdit.new(
               range: range,
               new_text: item.relative_type_name.to_s
-            )
+            ),
+            tags: tags
           )
           when Services::CompletionProvider::TextItem
             LSP::Interface::CompletionItem.new(

data/lib/steep/services/completion_provider.rb

@@ -53,19 +53,7 @@ module Steep
         end
 
         def deprecated?
-          annotations =
-            case entry = env.constant_entry(full_name)
-            when RBS::Environment::ConstantEntry
-              entry.decl.annotations
-            when RBS::Environment::ClassEntry, RBS::Environment::ModuleEntry
-              entry.decls.flat_map { _1.decl.annotations }
-            when RBS::Environment::ClassAliasEntry, RBS::Environment::ModuleAliasEntry
-              entry.decl.annotations
-            else
-              raise
-            end
-            
-          if AnnotationsHelper.deprecated_annotation?(annotations)
+          if AnnotationsHelper.deprecated_type_name?(full_name, env)
             true
           else
             false

data/lib/steep/services/signature_service.rb

@@ -294,7 +294,7 @@ module Steep
           end
 
           unless errors.empty?
-            # Builder won't be used.
+            errors.uniq! { |e| [e.class, e.message] }
             factory = AST::Types::Factory.new(builder: RBS::DefinitionBuilder.new(env: env, ancestor_builder: builder))
             return errors.map {|error| Diagnostic::Signature.from_rbs_error(error, factory: factory) }
           end

data/lib/steep/signature/validator.rb

@@ -144,17 +144,39 @@ module Steep
             validate_type_application_constraints(name, type_params, type_args, location: type.location)
           end
         end
-
-        type.each_type do |child|
-          validate_type_application(child)
-        end
       end
 
       def validate_type(type)
         Steep.logger.debug { "#{Location.to_string type.location}: Validating #{type}..." }
 
         validator.validate_type(type, context: nil)
+        validate_type_0(type)
+      end
+
+      def validate_type_0(type)
         validate_type_application(type)
+
+        case type
+        when RBS::Types::ClassInstance, RBS::Types::Interface, RBS::Types::ClassSingleton, RBS::Types::Alias
+          type_name = type.name
+          if type.location
+            location = type.location[:name]
+          end
+        end
+
+        if type_name && location
+          validate_type_name_deprecation(type_name, location)
+        end
+
+        type.each_type do |child|
+          validate_type_0(child)
+        end
+      end
+
+      def validate_type_name_deprecation(type_name, location)
+        if (_, message = AnnotationsHelper.deprecated_type_name?(type_name, env))
+          @errors << Diagnostic::Signature::DeprecatedTypeName.new(type_name, message, location: location)
+        end
       end
 
       def ancestor_to_type(ancestor)
@@ -269,6 +291,9 @@ module Steep
           type_params.each do |type_param|
             param = checker.factory.type_param(type_param)
 
+            validate_type(type_param.upper_bound_type) if type_param.upper_bound_type
+            validate_type(type_param.default_type) if type_param.default_type
+
             default_type = param.default_type or next
             upper_bound = param.upper_bound or next
 
@@ -296,6 +321,16 @@ module Steep
             args: entry.type_params.map { AST::Types::Any.instance() }
           )
 
+          entry.decls.each do |decl|
+            ast = decl.decl
+
+            unless AnnotationsHelper.deprecated_annotation?(ast.annotations)
+              if location = ast.location
+                validate_type_name_deprecation(name, location[:name])
+              end
+            end
+          end
+
           Steep.logger.tagged "#{name}" do
             builder.build_instance(name).tap do |definition|
               upper_bounds = definition.type_params_decl.each.with_object({}) do |param, bounds| #$ Hash[Symbol, AST::Types::t?]
@@ -353,6 +388,20 @@ module Steep
                     case ancestor
                     when RBS::Definition::Ancestor::Instance
                       validate_ancestor_application(name, ancestor)
+                      location =
+                        case ancestor.source
+                        when :super
+                          if (primary_decl = entry.primary.decl).is_a?(RBS::AST::Declarations::Class)
+                            primary_decl.super_class&.location
+                          end
+                        when nil
+                          # skip
+                        else
+                          ancestor.source.location
+                        end
+                      if location
+                        validate_type_name_deprecation(ancestor.name, location)
+                      end
                     end
                   end
 
@@ -632,6 +681,9 @@ module Steep
         rescue_validation_errors(name) do
           Steep.logger.debug "Validating class/module alias `#{name}`..."
           validator.validate_class_alias(entry: entry)
+          if location = entry.decl.location
+            validate_type_name_deprecation(entry.decl.old_name, location[:old_name])
+          end
         end
       end
 

data/lib/steep/type_construction.rb

@@ -3458,7 +3458,7 @@ module Steep
             block_annotations = source.annotations(block: node, factory: checker.factory, context: nesting)
             block_params or raise
 
-            constr = constr.synthesize_children(node.children[0])
+            constr = constr.synthesize_children(node.children[0], skips: [receiver])
 
             constr.type_block_without_hint(
               node: node,
@@ -3864,26 +3864,40 @@ module Steep
       if forwarded_args
         method_name or raise "method_name cannot be nil if `forwarded_args` is given, because proc/block doesn't support `...` arg"
 
-        (params, block = context.method_context&.forward_arg_type) or raise
+        method_context = context.method_context or raise
+        forward_arg_type = method_context.forward_arg_type
 
-        checker.with_context(self_type: self_type, instance_type: context.module_context.instance_type, class_type: context.module_context.module_type, constraints: constraints) do
-          result = checker.check_method_params(
-            :"... (argument forwarding)",
-            Subtyping::Relation.new(
-              sub_type: forwarded_args.params,
-              super_type: params
+        case forward_arg_type
+        when nil
+          if context.method_context.method_type
+            raise "Method context must have `forwarded_arg_type` if `...` node appears in it"
+          else
+            # Skips type checking forwarded argument because the method type is not given
+          end
+        when true
+          # Skip type checking forwarded argument because the method is untyped function
+        else
+          params, _block = forward_arg_type
+
+          checker.with_context(self_type: self_type, instance_type: context.module_context.instance_type, class_type: context.module_context.module_type, constraints: constraints) do
+            result = checker.check_method_params(
+              :"... (argument forwarding)",
+              Subtyping::Relation.new(
+                sub_type: forwarded_args.params,
+                super_type: params
+              )
             )
-          )
 
-          if result.failure?
-            errors.push(
-              Diagnostic::Ruby::IncompatibleArgumentForwarding.new(
-                method_name: method_name,
-                node: forwarded_args.node,
-                params_pair: [params, forwarded_args.params],
-                result: result
+            if result.failure?
+              errors.push(
+                Diagnostic::Ruby::IncompatibleArgumentForwarding.new(
+                  method_name: method_name,
+                  node: forwarded_args.node,
+                  params_pair: [params, forwarded_args.params],
+                  result: result
+                )
               )
-            )
+            end
           end
         end
       end
@@ -4105,6 +4119,15 @@ module Steep
 
                 fvs_.merge(method_type.type.params.free_variables) if method_type.type.params
                 fvs_.merge(method_type.block.type.params.free_variables) if method_type.block.type.params
+                (method_type.type.return_type.free_variables + method_type.block.type.return_type.free_variables).each do |var|
+                  if var.is_a?(Symbol)
+                    if constraints.unknown?(var)
+                      unless constraints.has_constraint?(var)
+                        fvs_.delete(var)
+                      end
+                    end
+                  end
+                end
 
                 constraints.solution(checker, variables: fvs_, context: ccontext)
               }
@@ -4116,7 +4139,7 @@ module Steep
                 block_constr = block_constr.update_type_env {|env| env.subst(s) }
                 block_constr = block_constr.update_context {|context|
                   context.with(
-                    self_type: method_type.block.self_type || context.self_type,
+                    self_type: context.self_type.subst(s),
                     type_env: context.type_env.subst(s),
                     block_context: context.block_context&.subst(s),
                     break_context: context.break_context&.subst(s)
@@ -4237,18 +4260,29 @@ module Steep
 
             case
             when forwarded_args_node = args.forwarded_args_node
-              (_, block = method_context!.forward_arg_type) or raise
+              case forward_arg_type = method_context!.forward_arg_type
+              when nil
+                if method_context!.method_type
+                  raise "Method context must have `forwarded_arg_type` if `...` node appears in it"
+                else
+                  # Skips type checking forwarded argument because the method type is not given
+                end
+              when true
+                # Skip type checking because it's untyped function
+              else
+                _, block = forward_arg_type
 
-              method_block_type = method_type.block&.to_proc_type || AST::Builtin.nil_type
-              forwarded_block_type = block&.to_proc_type || AST::Builtin.nil_type
+                method_block_type = method_type.block&.to_proc_type || AST::Builtin.nil_type
+                forwarded_block_type = block&.to_proc_type || AST::Builtin.nil_type
 
-              if result = constr.no_subtyping?(sub_type: forwarded_block_type, super_type: method_block_type)
-                errors << Diagnostic::Ruby::IncompatibleArgumentForwarding.new(
-                  method_name: method_name,
-                  node: forwarded_args_node,
-                  block_pair: [block, method_type.block],
-                  result: result
-                )
+                if result = constr.no_subtyping?(sub_type: forwarded_block_type, super_type: method_block_type)
+                  errors << Diagnostic::Ruby::IncompatibleArgumentForwarding.new(
+                    method_name: method_name,
+                    node: forwarded_args_node,
+                    block_pair: [block, method_type.block],
+                    result: result
+                  )
+                end
               end
 
             when arg.compatible?
@@ -4550,12 +4584,11 @@ module Steep
         next_type: block_context.body_type || AST::Builtin.any_type
       )
 
-      self_type = block_annotations.self_type || block_self_hint || self.self_type
+      self_type = block_self_hint || self.self_type
       module_context = self.module_context
 
       if implements = block_annotations.implement_module_annotation
         module_context = default_module_context(implements.name, nesting: nesting)
-
         self_type = module_context.module_type
       end
 
@@ -4563,6 +4596,11 @@ module Steep
         self_type = annotation_self_type
       end
 
+      # self_type here means the top-level `self` type because of the `Interface::Builder` implementation
+      if self_type
+        self_type = expand_self(self_type)
+      end
+
       self.class.new(
         checker: checker,
         source: source,

data/lib/steep/type_inference/context.rb

@@ -155,6 +155,10 @@ module Steep
         @type_env = type_env
         @call_context = call_context
         @variable_context = variable_context
+
+        if self_type.free_variables.include?(AST::Types::Self.instance)
+          raise "Context#self_type cannot contain `self`"
+        end
       end
 
       def with(method_context: self.method_context,

data/lib/steep/type_inference/logic_type_interpreter.rb

@@ -173,29 +173,41 @@ module Steep
             receiver_type = typing.type_of(node: receiver) if receiver
 
             if env[receiver] && receiver_type.is_a?(AST::Types::Union)
-              result = evaluate_union_method_call(node: node, env: env, receiver: receiver, receiver_type: receiver_type)
-              return result if result
+              result = evaluate_union_method_call(node: node, type: type, env: env, receiver: receiver, receiver_type: receiver_type)
+              if result
+                truthy_result = result[0] unless result[0].unreachable
+                falsy_result = result[1] unless result[1].unreachable
+              end
             end
 
-            if env[node]
-              truthy_type, falsy_type = factory.partition_union(type)
+            truthy_result ||= Result.new(type: type, env: env, unreachable: false)
+            falsy_result ||= Result.new(type: type, env: env, unreachable: false)
 
-              truthy_result =
-                if truthy_type
-                  Result.new(type: truthy_type, env: env.refine_types(pure_call_types: { node => truthy_type }), unreachable: false)
-                else
-                  Result.new(type: type, env: env, unreachable: true)
-                end
+            truthy_type, falsy_type = factory.partition_union(type)
 
-              falsy_result =
-                if falsy_type
-                  Result.new(type: falsy_type, env: env.refine_types(pure_call_types: { node => falsy_type }), unreachable: false)
-                else
-                  Result.new(type: type, env: env, unreachable: true)
-                end
+            if truthy_type
+              truthy_result = truthy_result.update_type { truthy_type }
+            else
+              truthy_result = truthy_result.update_type { BOT }.unreachable!
+            end
 
-              return [truthy_result, falsy_result]
+            if falsy_type
+              falsy_result = falsy_result.update_type { falsy_type }
+            else
+              falsy_result = falsy_result.update_type { BOT }.unreachable!
+            end
+
+            if truthy_result.env[node] && falsy_result.env[node]
+              if truthy_type
+                truthy_result = Result.new(type: truthy_type, env: truthy_result.env.refine_types(pure_call_types: { node => truthy_type }), unreachable: false)
+              end
+
+              if falsy_type
+                falsy_result = Result.new(type: falsy_type, env: falsy_result.env.refine_types(pure_call_types: { node => falsy_type }), unreachable: false)
+              end
             end
+
+            return [truthy_result, falsy_result]
           end
         end
 
@@ -416,7 +428,7 @@ module Steep
         end
       end
 
-      def evaluate_union_method_call(node:, env:, receiver:, receiver_type:)
+      def evaluate_union_method_call(node:, type:, env:, receiver:, receiver_type:)
         call_type = typing.call_of(node: node) rescue nil
         return unless call_type.is_a?(Steep::TypeInference::MethodCall::Typed)
 
@@ -453,8 +465,8 @@ module Steep
         )
 
         return [
-          Result.new(type: truthy_type, env: truthy_env, unreachable: truthy_type.nil?),
-          Result.new(type: falsy_type, env: falsy_env, unreachable: falsy_type.nil?)
+          Result.new(type: type, env: truthy_env, unreachable: truthy_type.nil?),
+          Result.new(type: type, env: falsy_env, unreachable: falsy_type.nil?)
         ]
       end
 

data/lib/steep/version.rb

@@ -1,3 +1,3 @@
 module Steep
-  VERSION = "1.10.0.dev.1"
+  VERSION = "1.10.0.pre.2"
 end

data/lib/steep.rb

@@ -151,6 +151,9 @@ require "steep/drivers/init"
 require "steep/drivers/vendor"
 require "steep/drivers/worker"
 require "steep/drivers/diagnostic_printer"
+require "steep/drivers/diagnostic_printer/base_formatter"
+require "steep/drivers/diagnostic_printer/code_formatter"
+require "steep/drivers/diagnostic_printer/github_actions_formatter"
 
 require "steep/annotations_helper"
 

data/sample/lib/deprecated.rb

@@ -2,3 +2,6 @@ Foo
 
 Bar.bar()
 
+Bar.new.hogehoge("")
+
+foo = nil #: Foo

data/sample/sig/deprecated.rbs

@@ -1,4 +1,4 @@
-%a{deprecated} class Foo end
+%a{deprecated: Use Bar instead} class Foo end
 
 class Bar
   # Original bar
@@ -6,6 +6,11 @@ class Bar
 
   # Overloading bar
   def self.bar: (String) -> String | ...
+
+  def hogehoge: (String) -> void
+              | %a{deprecated: Pass an positional argument} (string: String) -> void
 end
 
+type t = Foo
+
 %a{deprecated} $test: untyped

data/steep.gemspec

@@ -42,7 +42,7 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency "rainbow", ">= 2.2.2", "< 4.0"
   spec.add_runtime_dependency "listen", "~> 3.0"
   spec.add_runtime_dependency "language_server-protocol", ">= 3.17.0.4", "< 4.0"
-  spec.add_runtime_dependency "rbs", "~> 3.9.dev"
+  spec.add_runtime_dependency "rbs", "~> 3.9.pre"
   spec.add_runtime_dependency "concurrent-ruby", ">= 1.1.10"
   spec.add_runtime_dependency "terminal-table", ">= 2", "< 5"
   spec.add_runtime_dependency "securerandom", ">= 0.1"

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: steep
 version: !ruby/object:Gem::Version
-  version: 1.10.0.dev.1
+  version: 1.10.0.pre.2
 platform: ruby
 authors:
 - Soutaro Matsumoto
 bindir: exe
 cert_chain: []
-date: 2025-03-07 00:00:00.000000000 Z
+date: 2025-03-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -97,14 +97,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.9.dev
+        version: 3.9.pre
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.9.dev
+        version: 3.9.pre
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
   requirement: !ruby/object:Gem::Requirement
@@ -328,6 +328,9 @@ files:
 - lib/steep/drivers/check.rb
 - lib/steep/drivers/checkfile.rb
 - lib/steep/drivers/diagnostic_printer.rb
+- lib/steep/drivers/diagnostic_printer/base_formatter.rb
+- lib/steep/drivers/diagnostic_printer/code_formatter.rb
+- lib/steep/drivers/diagnostic_printer/github_actions_formatter.rb
 - lib/steep/drivers/init.rb
 - lib/steep/drivers/langserver.rb
 - lib/steep/drivers/print_project.rb