steep 1.5.3 → 1.6.0.pre.2

data/lib/steep/type_construction.rb

@@ -1305,29 +1305,39 @@ module Steep
             var = node.children[0]
             rhs = node.children[1]
 
-            var_type = context.type_env[var]
+            if SPECIAL_LVAR_NAMES.include?(var)
+              synthesize(rhs)
+              add_typing(node, type: AST::Builtin.any_type)
+            else
+              var_type = context.type_env[var]
 
-            if var_type
-              type, constr = check(rhs, var_type) do |expected_type, actual_type, result|
-                typing.add_error(
-                  Diagnostic::Ruby::IncompatibleAssignment.new(
-                    node: node,
-                    lhs_type: expected_type,
-                    rhs_type: actual_type,
-                    result: result
+              if var_type
+                type, constr = check(rhs, var_type) do |expected_type, actual_type, result|
+                  typing.add_error(
+                    Diagnostic::Ruby::IncompatibleAssignment.new(
+                      node: node,
+                      lhs_type: expected_type,
+                      rhs_type: actual_type,
+                      result: result
+                    )
                   )
-                )
+                end
+              else
+                type, constr = synthesize(rhs)
               end
-            else
-              type, constr = synthesize(rhs)
-            end
 
-            constr.add_typing(node, type: type)
+              constr.add_typing(node, type: type)
+            end
           end
 
         when :restarg
           yield_self do
             var = node.children[0]
+
+            if SPECIAL_LVAR_NAMES.include?(var)
+              return add_typing(node, type: AST::Builtin.any_type)
+            end
+
             type = context.type_env[var]
 
             unless type
@@ -1344,6 +1354,11 @@ module Steep
         when :kwrestarg
           yield_self do
             var = node.children[0]
+
+            if SPECIAL_LVAR_NAMES.include?(var)
+              return add_typing(node, type: AST::Builtin.any_type)
+            end
+
             type = context.type_env[var]
             unless type
               if context.method_context&.method_type
@@ -2893,6 +2908,8 @@ module Steep
             _, constr = constr.gvasgn(asgn_node, type)
           when :mlhs
             constr = (constr.type_masgn_type(asgn_node, type, masgn: masgn, optional: optional) or return)
+          else
+            _, constr = constr.synthesize_children(asgn_node).add_typing(asgn_node, type: AST::Builtin.any_type)
           end
 
           if node.type == :splat
@@ -3046,6 +3063,7 @@ module Steep
           end
         else
           parent_type, constr = synthesize(parent_node).to_ary
+          parent_type = expand_self(parent_type)
           parent_type = deep_expand_alias(parent_type)
 
           case parent_type
@@ -3284,7 +3302,14 @@ module Steep
 
         if call && constr
           case method_name.to_s
-          when "[]=", /\w=\Z/
+          when "[]="
+            if test_send_node(node) {|_, _, _, loc| !loc.dot }
+              last_arg = arguments.last or raise
+              if typing.has_type?(last_arg)
+                call = call.with_return_type(typing.type_of(node: last_arg))
+              end
+            end
+          when /\w=\Z/
             last_arg = arguments.last or raise
             if typing.has_type?(last_arg)
               call = call.with_return_type(typing.type_of(node: last_arg))
@@ -3292,7 +3317,7 @@ module Steep
           end
 
           if call.is_a?(TypeInference::MethodCall::Typed)
-            if (pure_call, type = constr.context.type_env.pure_method_calls[node])
+            if (pure_call, type = constr.context.type_env.pure_method_calls.fetch(node, nil))
               if type
                 call = pure_call.update(node: node, return_type: type)
                 constr.add_typing(node, type: call.return_type)
@@ -3345,12 +3370,14 @@ module Steep
             method_name: method_name,
             method_types: method.method_types
           )
+          decls = method.method_types.each_with_object(Set[]) {|type, decls| decls.merge(type.method_decls) }
           call = TypeInference::MethodCall::Error.new(
             node: node,
             context: context.call_context,
             method_name: method_name,
             receiver_type: receiver_type,
-            errors: errors
+            errors: errors,
+            method_decls: decls
           )
         end
 
@@ -3665,6 +3692,23 @@ module Steep
         end
       end
 
+      non_arity_errors = fails.reject do |call, _|
+        if call.is_a?(TypeInference::MethodCall::Error)
+          call.errors.any? do |error|
+            error.is_a?(Diagnostic::Ruby::UnexpectedBlockGiven) ||
+              error.is_a?(Diagnostic::Ruby::RequiredBlockMissing) ||
+              error.is_a?(Diagnostic::Ruby::UnexpectedPositionalArgument) ||
+              error.is_a?(Diagnostic::Ruby::InsufficientPositionalArguments) ||
+              error.is_a?(Diagnostic::Ruby::UnexpectedKeywordArgument) ||
+              error.is_a?(Diagnostic::Ruby::InsufficientKeywordArguments)
+          end
+        end
+      end
+
+      unless non_arity_errors.empty?
+        fails = non_arity_errors
+      end
+
       if fails.one?
         call, constr = fails[0]
 

data/lib/steep/type_inference/logic_type_interpreter.rb

@@ -367,6 +367,32 @@ module Steep
               [truthy_result, falsy_result]
             end
           end
+
+        when AST::Types::Logic::ArgIsAncestor
+          if receiver && (arg = arguments[0])
+            receiver_type = typing.type_of(node: receiver)
+            arg_type = factory.deep_expand_alias(typing.type_of(node: arg))
+
+            if arg_type.is_a?(AST::Types::Name::Singleton)
+              truthy_type = arg_type
+              falsy_type = receiver_type
+              truthy_env, falsy_env = refine_node_type(
+                env: env,
+                node: receiver,
+                truthy_type: truthy_type,
+                falsy_type: falsy_type
+              )
+
+              truthy_result = Result.new(type: TRUE, env: truthy_env, unreachable: false)
+              truthy_result.unreachable! unless truthy_type
+
+              falsy_result = Result.new(type: FALSE, env: falsy_env, unreachable: false)
+              falsy_result.unreachable! unless falsy_type
+
+              [truthy_result, falsy_result]
+            end
+          end
+
         when AST::Types::Logic::Not
           if receiver
             truthy_result, falsy_result = evaluate_node(env: env, node: receiver)

data/lib/steep/type_inference/method_params.rb

@@ -453,7 +453,7 @@ module Steep
           has_error = false
 
           keywords.each do |keyword|
-            rest_types << keyword_params.requireds[keyword] || keyword_params.optionals[keyword]
+            rest_types << (keyword_params.requireds[keyword] || keyword_params.optionals[keyword])
             has_error = true
           end
           keywords.clear

data/lib/steep/version.rb

@@ -1,3 +1,3 @@
 module Steep
-  VERSION = "1.5.3"
+  VERSION = "1.6.0.pre.2"
 end

data/lib/steep.rb

@@ -23,9 +23,6 @@ require "rbs"
 
 require "steep/path_helper"
 
-require "steep/shims/filter_map"
-require "steep/shims/symbol_start_with"
-
 require "steep/thread_waiter"
 require "steep/equatable"
 require "steep/method_name"
@@ -113,6 +110,7 @@ require "steep/services/stats_calculator"
 require "steep/services/file_loader"
 require "steep/services/goto_service"
 
+require "steep/server/delay_queue"
 require "steep/server/lsp_formatter"
 require "steep/server/change_buffer"
 require "steep/server/base_worker"

data/sig/shims/language-server_protocol.rbs

@@ -78,6 +78,18 @@ module LanguageServer
         MARKDOWN: "markdown"
       end
 
+      class MessageType
+        type t = 1 | 2 | 3 | 4
+
+        ERROR: 1
+
+        WARNING: 2
+
+        INFO: 3
+
+        LOG: 4
+      end
+
       module DiagnosticSeverity
         type t = 1 | 2 | 3 | 4
 

data/sig/steep/ast/types/logic.rbs

@@ -52,6 +52,11 @@ module Steep
           def initialize: (?location: untyped?) -> void
         end
 
+        # A type for `Class#<` or `Class#<=` call results.
+        class ArgIsAncestor < Base
+          def initialize: (?location: untyped?) -> void
+        end
+
         # A type with truthy/falsy type environment.
         class Env < Base
           attr_reader truthy: TypeInference::TypeEnv

data/sig/steep/ast/types.rbs

@@ -6,7 +6,7 @@ module Steep
            | Intersection  | Record | Tuple | Union
            | Name::Alias | Name::Instance | Name::Interface | Name::Singleton
            | Proc | Var
-           | Logic::Not | Logic::ReceiverIsNil | Logic::ReceiverIsNotNil | Logic::ReceiverIsArg | Logic::ArgIsReceiver | Logic::ArgEqualsReceiver | Logic::Env
+           | Logic::Not | Logic::ReceiverIsNil | Logic::ReceiverIsNotNil | Logic::ReceiverIsArg | Logic::ArgIsReceiver | Logic::ArgEqualsReceiver | Logic::ArgIsAncestor | Logic::Env
 
       # Variables and special types that is subject for substitution
       #

data/sig/steep/cli.rbs

@@ -24,6 +24,8 @@ module Steep
 
     def handle_jobs_option: (Drivers::Utils::JobsOption jobs_option, OptionParser opts) -> void
 
+    def setup_jobs_for_ci: (Drivers::Utils::JobsOption) -> void
+
     def process_init: () -> Integer
 
     def process_check: () -> Integer

data/sig/steep/diagnostic/ruby.rbs

@@ -98,19 +98,19 @@ module Steep
       end
 
       class UnresolvedOverloading < Base
-        attr_reader node: untyped
+        attr_reader node (): Parser::AST::Node
 
-        attr_reader receiver_type: untyped
+        attr_reader receiver_type: AST::Types::t
 
-        attr_reader method_name: untyped
+        attr_reader method_name: Symbol
 
-        attr_reader method_types: untyped
+        attr_reader method_types: Array[Interface::MethodType]
 
-        def initialize: (node: untyped, receiver_type: untyped, method_name: untyped, method_types: untyped) -> void
+        def initialize: (node: Parser::AST::Node, receiver_type: AST::Types::t, method_name: Symbol, method_types: Array[Interface::MethodType]) -> void
 
-        def header_line: () -> ::String
+        def header_line: () -> String
 
-        def detail_lines: () -> untyped
+        def detail_lines: () -> String
       end
 
       class ArgumentTypeMismatch < Base

data/sig/steep/project/pattern.rbs

@@ -1,22 +1,44 @@
 module Steep
   class Project
+    # `Pattern` class represents a pair of *positive* and *negative* patterns that may match with a pathname
+    #
+    # ```rb
+    # pat = Pattern.new(patterns: ["app/models"], ignores: ["app/models/account.rb"], ext: ".rbs")
+    #
+    # pat =~ "app/models/group.rb"    # => true
+    # pat =~ "app/models/account.rb"  # => false
+    # ```
+    #
+    # The pattern may be:
+    #
+    # 1. Directory name pattern -- `lib`, or
+    # 2. *Glob* pattern -- `foo/**/bar.rb`
+    #
     class Pattern
+      # Positive patterns, which is tested with `fnmatch`
       attr_reader patterns: Array[String]
 
+      # Negative patterns, which is tested with `fnmatch`
       attr_reader ignores: Array[String]
 
+      # Positive *dir name* pattern constructed from `#patterns`, which is tested with `start_with?`
       attr_reader prefixes: Array[String]
 
+      # Negative *dir name* pattern constructed from `#ignores`, which is tested with `start_with?`
       attr_reader ignore_prefixes: Array[String]
 
       attr_reader ext: String
 
       def initialize: (patterns: Array[String], ext: String, ?ignores: Array[String]) -> void
 
+      # Returns `true` if given path matches to *positive* pattern, but doesn't match to *negative* pattern
+      #
       def =~: (Pathname | String path) -> bool
 
+      # Returns true if given `Pathname` matches to *positive* pattern
       def match?: (Pathname path) -> bool
 
+      # Returns true if given `Pathname` matches to *negative* pattern
       def ignore?: (Pathname path) -> bool
 
       def test_string: (Pathname path, Array[String] patterns, Array[String] prefixes) -> bool

data/sig/steep/server/change_buffer.rbs

@@ -27,6 +27,10 @@ module Steep
       # Load changes from a request with `DidChangeTextDocumentParams` into `buffered_changes`
       #
       def collect_changes: (untyped request) -> void
+
+      # Reset the content of `uri` to `text`
+      # 
+      def reset_change: (uri: String, text: String) -> void
     end
   end
 end

data/sig/steep/server/delay_queue.rbs

@@ -0,0 +1,37 @@
+module Steep
+  module Server
+    # DelayQueue provides a queue that delays running given job
+    #
+    # 1. The `delay` is specific to a DelayQueue instance, not job specific
+    # 2. It executes only the last job
+    #
+    # ```ruby
+    # queue = DelayQueue.new(delay: 0.5)
+    # queue.execute { pp 1 }
+    # queue.execute { pp 2 }
+    # queue.execute { pp 3 }
+    #
+    # # => Will print only `3`, and the jobs printing `1` and `2` will be discarded
+    # ```
+    #
+    # The job will run on `#thread`.
+    #
+    class DelayQueue
+      attr_reader delay: Float
+
+      attr_reader thread: Thread
+
+      attr_reader queue: Thread::Queue
+
+      attr_reader last_task: Proc
+
+      def initialize: (delay: Float) -> void
+
+      # The `#execute` method is not thread safe
+      #
+      # You should synchronize yourself if you want to call the method from multiple threads.
+      #
+      def execute: () { () -> void } -> void
+    end
+  end
+end

data/sig/steep/server/master.rbs

@@ -225,6 +225,8 @@ module Steep
 
       attr_accessor typecheck_automatically: bool
 
+      attr_reader start_type_checking_queue: DelayQueue
+
       def initialize: (project: Project, reader: untyped, writer: untyped, interaction_worker: WorkerProcess?, typecheck_workers: Array[WorkerProcess], ?queue: Thread::Queue) -> void
 
       # Start the Steep language server
@@ -252,6 +254,8 @@ module Steep
 
       def work_done_progress_supported?: () -> bool
 
+      def file_system_watcher_supported?: () -> bool
+
       def process_message_from_client: (untyped message) -> void
 
       def process_message_from_worker: (untyped message, worker: WorkerProcess) -> void

data/sig/steep/services/stats_calculator.rbs

@@ -1,17 +1,41 @@
 module Steep
   module Services
     class StatsCalculator
-      SuccessStats: untyped
+      class SuccessStats
+        attr_reader target: Project::Target
 
-      ErrorStats: untyped
+        attr_reader path: Pathname
 
-      attr_reader service: untyped
+        attr_reader typed_calls_count: Integer
 
-      def initialize: (service: untyped) -> void
+        attr_reader untyped_calls_count: Integer
 
-      def project: () -> untyped
+        attr_reader error_calls_count: Integer
 
-      def calc_stats: (untyped target, file: untyped) -> untyped
+        def initialize: (target: Project::Target, path: Pathname, typed_calls_count: Integer, untyped_calls_count: Integer, error_calls_count: Integer) -> void
+
+        def as_json: () -> Hash[Symbol, untyped]
+      end
+
+      class ErrorStats
+        attr_reader target: Project::Target
+
+        attr_reader path: Pathname
+
+        def initialize: (target: Project::Target, path: Pathname) -> void
+
+        def as_json: () -> Hash[Symbol, untyped]
+      end
+
+      type stats = SuccessStats | ErrorStats
+
+      attr_reader service: TypeCheckService
+
+      def initialize: (service: TypeCheckService) -> void
+
+      def project: () -> Project
+
+      def calc_stats: (Project::Target target, file: TypeCheckService::SourceFile) -> stats
     end
   end
 end

data/sig/steep/services/type_name_completion.rbs

@@ -112,9 +112,22 @@ module Steep
 
       def format_constant_name: (TypeName) -> String
 
+      def resolve_used_name: (TypeName) -> TypeName?
+
+      private
+
+      # Yield type names defined in the environment
+      #
+      # * Yields an absolute type name if it is defined in the environment
+      # * Yields an relative type name if it is imported with `use` declerative
+      #
+      # Alias classes/modules and types under them are yielded.
+      #
       def each_type_name: () { (TypeName) -> void } -> void
                         | () -> Enumerator[TypeName, void]
 
+      def each_type_name_under: (TypeName module_name, TypeName normalized_name, table: Hash[Namespace, Array[TypeName]]) { (TypeName) -> void } -> void
+
       def each_outer_module: (?Resolver::context) { (Namespace) -> void } -> Namespace
                            | () -> Enumerator[Namespace, void]
     end

data/sig/steep/signature/validator.rbs

@@ -66,6 +66,11 @@ module Steep
 
       def validate_one_global: (Symbol name, RBS::Environment::GlobalEntry) -> void
 
+      # Validate type alias
+      #
+      # 1. Make sure the outer namespace of given `name` exists
+      # 2. Make sure the type alias is valid with respect to `RBS::Validator`
+      # 
       def validate_one_alias: (RBS::TypeName name, ?RBS::Environment::TypeAliasEntry entry) -> void
 
       def validate_one_class_decl: (RBS::TypeName) -> void

data/sig/steep/subtyping/check.rbs

@@ -123,7 +123,7 @@ module Steep
       # Returns nil if there is no path.
       def hole_path: (AST::Types::t `type`, ?Array[AST::Types::t] path) -> Array[AST::Types::t]?
 
-      def Relation: [T < Object] (T sub, T sup) -> Relation[T]
+      def Relation: [T < Relation::_Subject] (T sub, T sup) -> Relation[T]
     end
   end
 end

data/sig/steep/subtyping/relation.rbs

@@ -1,6 +1,16 @@
 module Steep
   module Subtyping
-    class Relation[out Subject < Object]
+    class Relation[out Subject < _Subject]
+      interface _Subject
+        def hash: () -> Integer
+
+        def is_a?: (Module) -> bool
+
+        def class: () -> Class
+
+        def !: () -> bool
+      end
+
       attr_reader sub_type: Subject
 
       attr_reader super_type: Subject

data/sig/steep/subtyping/result.rbs

@@ -45,7 +45,7 @@ module Steep
         @failure: bool
 
         # Returns `false` if no future `#add` changes the result.
-        def add: [T < Object] (*Relation[T] relations) { (Relation[T]) -> t? } -> bool
+        def add: [T < Relation::_Subject] (*Relation[T] relations) { (Relation[T]) -> t? } -> bool
 
         # Returns `false` if no future `#add` changes the result.
         def add_result: (t?) -> bool

data/sig/steep/type_construction.rbs

@@ -271,7 +271,7 @@ module Steep
     def calculate_interface: (AST::Types::t `type`, private: bool) -> Interface::Shape?
                            | (AST::Types::t `type`, Symbol method_name, private: bool) -> Interface::Shape::Entry?
 
-    def expand_self: (untyped `type`) -> untyped
+    def expand_self: (AST::Types::t `type`) -> AST::Types::t
 
     SPECIAL_METHOD_NAMES: Hash[Symbol, Set[method_name]]
 

data/smoke/block/test_expectations.yml

@@ -98,31 +98,27 @@
   - range:
       start:
         line: 10
-        character: 0
+        character: 12
       end:
         line: 10
-        character: 29
+        character: 28
     severity: ERROR
     message: |-
-      Cannot find compatible overloading of method `map` of type `::Array[::Integer]`
-      Method types:
-        def map: [U] () { (::Integer) -> U } -> ::Array[U]
-               | () -> ::Enumerator[::Integer, ::Array[untyped]]
-    code: Ruby::UnresolvedOverloading
+      Cannot pass a value of type `::Proc` as a block-pass-argument of type `^(::Integer) -> U(3)`
+        ::Proc <: ^(::Integer) -> U(3)
+    code: Ruby::BlockTypeMismatch
   - range:
       start:
         line: 11
-        character: 0
+        character: 12
       end:
         line: 11
-        character: 21
+        character: 20
     severity: ERROR
     message: |-
-      Cannot find compatible overloading of method `map` of type `::Array[::Integer]`
-      Method types:
-        def map: [U] () { (::Integer) -> U } -> ::Array[U]
-               | () -> ::Enumerator[::Integer, ::Array[untyped]]
-    code: Ruby::UnresolvedOverloading
+      Cannot pass a value of type `::Proc` as a block-pass-argument of type `^(::Integer) -> U(4)`
+        ::Proc <: ^(::Integer) -> U(4)
+    code: Ruby::BlockTypeMismatch
 - file: e.rb
   diagnostics:
   - range:

data/smoke/enumerator/test_expectations.yml

@@ -10,11 +10,11 @@
         character: 3
     severity: ERROR
     message: |-
-      Cannot find compatible overloading of method `with_object` of type `::Enumerator[::Integer, ::Array[::Integer]]`
-      Method types:
-        def with_object: [U] (U) { (::Integer, U) -> untyped } -> U
-                       | [U] (U) -> ::Enumerator[[::Integer, U], U]
-    code: Ruby::UnresolvedOverloading
+      Unsatisfiable constraint `::String <: U(1) <: ::Hash[::Symbol, ::String]` is generated through (U(1)) { (::Integer, U(1)) -> untyped } -> U(1)
+        ::String <: ::Hash[::Symbol, ::String]
+          ::Object <: ::Hash[::Symbol, ::String]
+            ::BasicObject <: ::Hash[::Symbol, ::String]
+    code: Ruby::UnsatisfiableConstraint
 - file: b.rb
   diagnostics:
   - range:
@@ -40,8 +40,8 @@
         character: 3
     severity: ERROR
     message: |-
-      Cannot find compatible overloading of method `with_object` of type `::Enumerator[::Integer, ::Array[::Integer]]`
-      Method types:
-        def with_object: [U] (U) { (::Integer, U) -> untyped } -> U
-                       | [U] (U) -> ::Enumerator[[::Integer, U], U]
-    code: Ruby::UnresolvedOverloading
+      Unsatisfiable constraint `::Array[untyped] <: U(3) <: ::String` is generated through (U(3)) { (::Integer, U(3)) -> untyped } -> U(3)
+        ::Array[untyped] <: ::String
+          ::Object <: ::String
+            ::BasicObject <: ::String
+    code: Ruby::UnsatisfiableConstraint

data/smoke/integer/test_expectations.yml

@@ -102,20 +102,9 @@
     message: |-
       Cannot find compatible overloading of method `Integer` of type `::Object`
       Method types:
-        def Integer: ((::Numeric | ::String), ?exception: bool) -> ::Integer
-                   | (::String, ?::Integer, ?exception: bool) -> ::Integer
-    code: Ruby::UnresolvedOverloading
-  - range:
-      start:
-        line: 26
-        character: 0
-      end:
-        line: 26
-        character: 12
-    severity: ERROR
-    message: |-
-      Cannot find compatible overloading of method `Integer` of type `::Object`
-      Method types:
-        def Integer: ((::Numeric | ::String), ?exception: bool) -> ::Integer
-                   | (::String, ?::Integer, ?exception: bool) -> ::Integer
+        def Integer: ((::_ToInt | ::_ToI), ?exception: true) -> ::Integer
+                   | ((::_ToInt | ::_ToI), exception: bool) -> (::Integer | nil)
+                   | (::string, ?::int, ?exception: true) -> ::Integer
+                   | (::string, ?::int, exception: bool) -> (::Integer | nil)
+                   | (untyped, ?untyped, exception: false) -> nil
     code: Ruby::UnresolvedOverloading

data/smoke/regression/hello world.rb

@@ -0,0 +1 @@
+1.foo()