steep 1.5.2 → 1.6.0.pre.1

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/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()

data/smoke/regression/test_expectations.yml

@@ -35,6 +35,18 @@
     severity: ERROR
     message: 'Cannot find the declaration of class: `Foo`'
     code: Ruby::UnknownConstant
+- file: hello world.rb
+  diagnostics:
+  - range:
+      start:
+        line: 1
+        character: 2
+      end:
+        line: 1
+        character: 5
+    severity: ERROR
+    message: Type `::Integer` does not have method `foo`
+    code: Ruby::NoMethod
 - file: issue_332.rb
   diagnostics:
   - range:

data/steep.gemspec

@@ -26,7 +26,7 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.required_ruby_version = '>= 2.7.0'
+  spec.required_ruby_version = '>= 3.0.0'
 
   spec.add_runtime_dependency "parser", ">= 3.1"
   spec.add_runtime_dependency "activesupport", ">= 5.1"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: steep
 version: !ruby/object:Gem::Version
-  version: 1.5.2
+  version: 1.6.0.pre.1
 platform: ruby
 authors:
 - Soutaro Matsumoto
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-07-27 00:00:00.000000000 Z
+date: 2023-10-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -332,6 +332,7 @@ files:
 - lib/steep/range_extension.rb
 - lib/steep/server/base_worker.rb
 - lib/steep/server/change_buffer.rb
+- lib/steep/server/delay_queue.rb
 - lib/steep/server/interaction_worker.rb
 - lib/steep/server/lsp_formatter.rb
 - lib/steep/server/master.rb
@@ -350,8 +351,6 @@ files:
 - lib/steep/services/stats_calculator.rb
 - lib/steep/services/type_check_service.rb
 - lib/steep/services/type_name_completion.rb
-- lib/steep/shims/filter_map.rb
-- lib/steep/shims/symbol_start_with.rb
 - lib/steep/signature/validator.rb
 - lib/steep/source.rb
 - lib/steep/subtyping/cache.rb
@@ -467,6 +466,7 @@ files:
 - sig/steep/range_extension.rbs
 - sig/steep/server/base_worker.rbs
 - sig/steep/server/change_buffer.rbs
+- sig/steep/server/delay_queue.rbs
 - sig/steep/server/interaction_worker.rbs
 - sig/steep/server/lsp_formatter.rbs
 - sig/steep/server/master.rbs
@@ -712,6 +712,7 @@ files:
 - smoke/regression/fun.rb
 - smoke/regression/fun.rbs
 - smoke/regression/hash.rb
+- smoke/regression/hello world.rb
 - smoke/regression/issue_328.rb
 - smoke/regression/issue_328.rbs
 - smoke/regression/issue_332.rb
@@ -777,12 +778,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.7.0
+      version: 3.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.4.10
 signing_key:

data/lib/steep/shims/filter_map.rb

@@ -1,30 +0,0 @@
-# Steep runs on Ruby 2.6 and it needs a shim of `filter_map`
-
-module Shims
-  module EnumerableFilterMap
-    def filter_map(&block)
-      if block
-        result = []
-
-        each do |element|
-          if value = yield(element)
-            result << value
-          end
-        end
-
-        result
-      else
-        enum_for :filter_map
-      end
-    end
-  end
-
-  unless Enumerable.method_defined?(:filter_map)
-    Enumerable.include EnumerableFilterMap
-
-    module ::Enumerable
-      alias filter_map filter_map
-    end
-  end
-end
-

data/lib/steep/shims/symbol_start_with.rb

@@ -1,18 +0,0 @@
-# Steep runs on Ruby 2.6 and it needs a shim of `Symbol#start_with?`
-
-module Shims
-  module SymbolStartWith
-    def start_with?(*args)
-      to_s.start_with?(*args)
-    end
-
-    def end_with?(*args)
-      to_s.end_with?(*args)
-    end
-  end
-
-  unless Symbol.method_defined?(:start_with?)
-    Symbol.include(SymbolStartWith)
-  end
-end
-