steep 1.9.4 → 1.10.0.pre.1

data/lib/steep/type_construction.rb

@@ -155,7 +155,6 @@ module Steep
                                  definition.methods[method_name]&.yield_self do |method|
                                    method.method_types
                                      .map {|method_type| checker.factory.method_type(method_type) }
-                                     .select {|method_type| method_type.is_a?(Interface::MethodType) }
                                      .inject {|t1, t2| t1 + t2}
                                  end
                                end
@@ -163,6 +162,18 @@ module Steep
 
       method_type = annotation_method_type || definition_method_type
 
+      unless method_type
+        if definition
+          typing.add_error(
+            Diagnostic::Ruby::UndeclaredMethodDefinition.new(method_name: method_name, type_name: definition.type_name, node: node)
+          )
+        else
+          typing.add_error(
+            Diagnostic::Ruby::MethodDefinitionInUndeclaredModule.new(method_name: method_name, node: node)
+          )
+        end
+      end
+
       if (annotation_return_type = annots&.return_type) && (method_type_return_type = method_type&.type&.return_type)
         check_relation(sub_type: annotation_return_type, super_type: method_type_return_type).else do |result|
           typing.add_error(
@@ -1483,6 +1494,10 @@ module Steep
                   Diagnostic::Ruby::UnknownConstant.new(node: name_node, name: name_node.children[1]).class!
                 )
               end
+
+              if class_name
+                check_deprecation_constant(class_name, name_node, name_node.location.expression)
+              end
             else
               _, constr = synthesize(name_node)
             end
@@ -1538,6 +1553,10 @@ module Steep
               _, constr, module_name = synthesize_constant_decl(name_node, name_node.children[0], name_node.children[1]) do
                 typing.add_error Diagnostic::Ruby::UnknownConstant.new(node: name_node, name: name_node.children[1]).module!
               end
+
+              if module_name
+                check_deprecation_constant(module_name, name_node, name_node.location.expression)
+              end
             else
               _, constr = synthesize(name_node)
             end
@@ -1608,6 +1627,7 @@ module Steep
 
             if name
               typing.source_index.add_reference(constant: name, ref: node)
+              constr.check_deprecation_constant(name, node, node.location.expression)
             end
 
             Pair.new(type: type, constr: constr)
@@ -1626,6 +1646,8 @@ module Steep
 
             if constant_name
               typing.source_index.add_definition(constant: constant_name, definition: node)
+              location = node.location #: Parser::Source::Map & Parser::AST::_Variable
+              constr.check_deprecation_constant(constant_name, node, location.name)
             end
 
             value_type, constr = constr.synthesize(node.children.last, hint: constant_type)
@@ -2015,8 +2037,8 @@ module Steep
                 branch_result =
                   if body
                     when_clause_constr
-                      .for_branch(body)
                       .update_type_env {|env| env.join(*body_envs) }
+                      .for_branch(body)
                       .tap {|constr| typing.cursor_context.set_node_context(body, constr.context) }
                       .synthesize(body, hint: hint)
                   else
@@ -2040,14 +2062,16 @@ module Steep
 
               if els
                 branch_results << condition_constr.synthesize(els, hint: hint)
+              else
+                branch_results << Pair.new(type: AST::Builtin.nil_type, constr: condition_constr)
+              end
+
+              branch_results.reject! do |result|
+                result.type.is_a?(AST::Types::Bot)
               end
 
               types = branch_results.map(&:type)
               envs = branch_results.map {|result| result.constr.context.type_env }
-
-              unless els
-                types << AST::Builtin.nil_type
-              end
             end
 
             constr = constr.update_type_env do |env|
@@ -2387,6 +2411,9 @@ module Steep
             lhs_type = context.type_env[name]
             rhs_type, constr = synthesize(rhs, hint: lhs_type).to_ary
 
+            location = node.location #: Parser::Source::Map & Parser::AST::_Variable
+            constr.check_deprecation_global(name, node, location.name)
+
             type, constr = constr.gvasgn(node, rhs_type)
 
             constr.add_typing(node, type: type)
@@ -2395,6 +2422,9 @@ module Steep
         when :gvar
           yield_self do
             name = node.children.first
+
+            check_deprecation_global(name, node, node.location.expression)
+
             if type = context.type_env[name]
               add_typing(node, type: type)
             else
@@ -2943,7 +2973,7 @@ module Steep
               nil
             ]
           else
-            # No neesting
+            # No nesting
             synthesize_constant(node, nil, constant_name, &block)
           end
         end
@@ -3207,6 +3237,18 @@ module Steep
       end
     end
 
+    def deprecated_send?(call)
+      return unless call.node.type == :send || call.node.type == :csend
+
+      call.method_decls.each do |decl|
+        if pair = AnnotationsHelper.deprecated_annotation?(decl.method_def.each_annotation.to_a)
+          return pair
+        end
+      end
+
+      nil
+    end
+
     def type_send_interface(node, interface:, receiver:, receiver_type:, method_name:, arguments:, block_params:, block_body:, tapp:, hint:)
       method = interface.methods[method_name]
 
@@ -3260,6 +3302,20 @@ module Steep
                 end
               end
             end
+
+            if (_, message = deprecated_send?(call))
+              send_node, _ = deconstruct_sendish_and_block_nodes(node)
+              send_node or raise
+              _, _, _, loc = deconstruct_send_node!(send_node)
+
+              constr.typing.add_error(
+                Diagnostic::Ruby::DeprecatedReference.new(
+                  node: node,
+                  location: loc.selector,
+                  message: message
+                )
+              )
+            end
           end
 
           if node.type == :csend || ((node.type == :block || node.type == :numblock) && node.children[0].type == :csend)
@@ -3808,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
@@ -4181,18 +4251,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?
@@ -4440,7 +4521,7 @@ module Steep
 
       param_types = param_types_hash.each.with_object({}) do |pair, hash| #$ Hash[Symbol, [AST::Types::t, AST::Types::t?]]
         name, type = pair
-        # skip unamed arguments `*`, `**` and `&`
+        # skip unnamed arguments `*`, `**` and `&`
         next if name.nil?
         hash[name] = [type, nil]
       end
@@ -5166,5 +5247,43 @@ module Steep
         end
       end
     end
+
+    def check_deprecation_global(name, node, location)
+      if global_entry = checker.factory.env.global_decls[name]
+        if (_, message = AnnotationsHelper.deprecated_annotation?(global_entry.decl.annotations))
+          typing.add_error(
+            Diagnostic::Ruby::DeprecatedReference.new(
+              node: node,
+              location: location,
+              message: message
+            )
+          )
+        end
+      end
+    end
+
+    def check_deprecation_constant(name, node, location)
+      entry = checker.builder.factory.env.constant_entry(name)
+
+      annotations =
+        case entry
+        when RBS::Environment::ModuleEntry, RBS::Environment::ClassEntry
+          entry.decls.flat_map { _1.decl.annotations }
+        when RBS::Environment::ConstantEntry, RBS::Environment::ClassAliasEntry, RBS::Environment::ModuleAliasEntry
+          entry.decl.annotations
+        end
+
+      if annotations
+        if (_, message = AnnotationsHelper.deprecated_annotation?(annotations))
+          typing.add_error(
+            Diagnostic::Ruby::DeprecatedReference.new(
+              node: node,
+              location: location,
+              message: message
+            )
+          )
+        end
+      end
+    end
   end
 end

data/lib/steep/type_inference/case_when.rb

@@ -243,6 +243,8 @@ module Steep
           end
         end
 
+        results.reject! { _1.type.is_a?(AST::Types::Bot) }
+
         types = results.map {|result| result.type }
         envs = results.map {|result| result.env }
 

data/lib/steep/type_inference/logic_type_interpreter.rb

@@ -169,25 +169,45 @@ module Steep
               return [truthy_result, falsy_result]
             end
           else
-            if env[node]
-              truthy_type, falsy_type = factory.partition_union(type)
+            receiver, *_ = node.children
+            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, 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
 
-              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_result ||= Result.new(type: type, env: env, unreachable: false)
+            falsy_result ||= Result.new(type: type, env: env, unreachable: false)
 
-              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
+            truthy_type, falsy_type = factory.partition_union(type)
 
-              return [truthy_result, falsy_result]
+            if truthy_type
+              truthy_result = truthy_result.update_type { truthy_type }
+            else
+              truthy_result = truthy_result.update_type { BOT }.unreachable!
             end
+
+            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
 
@@ -408,6 +428,48 @@ module Steep
         end
       end
 
+      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)
+
+        truthy_types = [] #: Array[AST::Types::t]
+        falsy_types = [] #: Array[AST::Types::t]
+
+        receiver_type.types.each do |type|
+          if shape = subtyping.builder.shape(type, config)
+            method = shape.methods[call_type.method_name] or raise
+            method_type = method.method_types.find do |method_type|
+              call_type.method_decls.any? {|decl| factory.method_type(decl.method_type) == method_type }
+            end
+            if method_type
+              return_type = method_type.type.return_type
+              truthy, falsy = factory.partition_union(return_type)
+              truthy_types << type if truthy
+              falsy_types << type if falsy
+              next
+            end
+          end
+
+          truthy_types << type
+          falsy_types << type
+        end
+
+        truthy_type = truthy_types.empty? ? BOT : AST::Types::Union.build(types: truthy_types)
+        falsy_type = falsy_types.empty? ? BOT : AST::Types::Union.build(types: falsy_types)
+
+        truthy_env, falsy_env = refine_node_type(
+          env: env,
+          node: receiver,
+          truthy_type: truthy_type,
+          falsy_type: falsy_type
+        )
+
+        return [
+          Result.new(type: type, env: truthy_env, unreachable: truthy_type.nil?),
+          Result.new(type: type, env: falsy_env, unreachable: falsy_type.nil?)
+        ]
+      end
+
       def decompose_value(node)
         case node.type
         when :lvar

data/lib/steep/type_inference/method_call.rb

@@ -124,12 +124,14 @@ module Steep
 
         def pure?
           method_decls.all? do |method_decl|
-            case member = method_decl.method_def.member
-            when RBS::AST::Members::MethodDefinition
-              member.annotations.any? {|annotation| annotation.string == "pure" }
+            case method_decl.method_def.member
             when RBS::AST::Members::Attribute
               # The attribute writer is not pure
               !method_decl.method_name.method_name.end_with?("=")
+            else
+              method_decl.method_def.each_annotation.any? do |annotation|
+                annotation.string == "pure"
+              end
             end
           end
         end

data/lib/steep/version.rb

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

data/lib/steep.rb

@@ -17,6 +17,7 @@ require "yaml"
 require "securerandom"
 require "base64"
 require "time"
+require 'socket'
 
 require "concurrent/utility/processor_counter"
 require "terminal-table"
@@ -150,6 +151,11 @@ 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"
 
 if ENV["NO_COLOR"]
   Rainbow.enabled = false
@@ -226,6 +232,10 @@ module Steep
     end
   end
 
+  def self.can_fork?
+    defined?(fork)
+  end
+
   class Sampler
     def initialize()
       @samples = []

data/manual/ruby-diagnostics.md

@@ -40,7 +40,7 @@ A type annotation has a syntax error.
 ### Ruby code
 
 ```ruby
-# @type var foo: () -> 
+# @type var foo: () ->
 ```
 
 ### Diagnostic
@@ -237,6 +237,52 @@ test.rb:4:6: [error] ::Kernel is declared as a module in RBS
 | - | - | - | - | - |
 | error | error | error | - | - |
 
+<a name='Ruby::DeprecatedReference'></a>
+## Ruby::DeprecatedReference
+
+Method call or constant reference is deprecated.
+
+### RBS
+
+```rbs
+%a{deprecated} class Foo end
+
+class Bar
+  %a{deprecated: since v0.9} def self.bar: () -> void
+end
+```
+
+### Ruby code
+
+```ruby
+Foo
+
+Bar.bar()
+```
+
+### Diagnostic
+
+```
+lib/deprecated.rb:1:0: [warning] The constant is deprecated
+│ Diagnostic ID: Ruby::DeprecatedReference
+│
+└ Foo
+  ~~~
+
+lib/deprecated.rb:3:4: [warning] The method is deprecated: since v0.9
+│ Diagnostic ID: Ruby::DeprecatedReference
+│
+└ Bar.bar()
+      ~~~
+```
+
+
+### Severity
+
+| all_error | strict | default | lenient | silent |
+| - | - | - | - | - |
+| error | warning | warning | warning | - |
+
 <a name='Ruby::DifferentMethodParameterKind'></a>
 ## Ruby::DifferentMethodParameterKind
 
@@ -703,6 +749,36 @@ test.rb:2:6: [error] Cannot allow method body have type `::Integer` because decl
 | - | - | - | - | - |
 | error | error | error | warning | - |
 
+<a name='Ruby::MethodDefinitionInUndeclaredModule'></a>
+## Ruby::MethodDefinitionInUndeclaredModule
+
+A `def` syntax doesn't have method type because the module/class is undefined in RBS.
+
+### Ruby code
+
+```ruby
+class UndeclaredClass
+  def to_s = 123
+end
+```
+
+### Diagnostic
+
+```
+test.rb:2:6: [error] Method `to_s` is defined in undeclared module
+│ Diagnostic ID: Ruby::MethodDefinitionInUndeclaredModule
+│
+└   def to_s = 123
+        ~~~~
+```
+
+
+### Severity
+
+| all_error | strict | default | lenient | silent |
+| - | - | - | - | - |
+| error | warning | information | hint | - |
+
 <a name='Ruby::MethodDefinitionMissing'></a>
 ## Ruby::MethodDefinitionMissing
 
@@ -1235,6 +1311,43 @@ test.rb:2:4: [error] Empty hash doesn't have type annotation
 | - | - | - | - | - |
 | error | error | warning | hint | - |
 
+<a name='Ruby::UndeclaredMethodDefinition'></a>
+## Ruby::UndeclaredMethodDefinition
+
+A `def` syntax doesn't have corresponding RBS method definition.
+
+### RBS
+
+```rbs
+class Foo
+end
+```
+
+### Ruby code
+
+```ruby
+class Foo
+  def undeclared = nil
+end
+```
+
+### Diagnostic
+
+```
+test.rb:2:6: [error] Method `::Foo#undeclared` is not declared in RBS
+│ Diagnostic ID: Ruby::UndeclaredMethodDefinition
+│
+└   def undeclared = nil
+        ~~~~~~~~~~
+```
+
+
+### Severity
+
+| all_error | strict | default | lenient | silent |
+| - | - | - | - | - |
+| error | warning | warning | information | - |
+
 <a name='Ruby::UnexpectedBlockGiven'></a>
 ## Ruby::UnexpectedBlockGiven
 

data/sample/Steepfile

@@ -5,8 +5,6 @@ target :lib do
 
   check "lib"                       # Directory name
 
-  library "rbs"
-
   # configure_code_diagnostics(D::Ruby.strict)       # `strict` diagnostics setting
   # configure_code_diagnostics(D::Ruby.lenient)      # `lenient` diagnostics setting
   # configure_code_diagnostics(D::Ruby.silent)       # `silent` diagnostics setting

data/sample/lib/conference.rb

@@ -7,19 +7,33 @@ class Conference
     @title = title
     @year = year
   end
+
+  def hello_world
+
+  end
 end
 
 Conference.new()
 
 Konference.new()
 
+class Hogehogehoge
+  def to_s = 123
 
+  def foo = 23
+end
 
 # @type var foo: Konference
 
 foo = Conference.new
 
+class Conference
+  def hello = 123
+end
+
 class Conference12
+  def hello = 123
+
   class Integer
   end
 end

data/sample/lib/deprecated.rb

@@ -0,0 +1,7 @@
+Foo
+
+Bar.bar()
+
+Bar.new.hogehoge("")
+
+foo = nil #: Foo