steep 1.4.0 → 1.5.0.pre.1

data/lib/steep.rb

@@ -1,7 +1,7 @@
 require "steep/version"
 
 require "pathname"
-require "parser/ruby31"
+require "parser/ruby32"
 require "active_support"
 require "active_support/core_ext/object/try"
 require "active_support/core_ext/string/inflections"
@@ -26,6 +26,7 @@ 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"
 require "steep/node_helper"
@@ -168,6 +169,7 @@ module Steep
     @log_output = output
     prev_level = @logger&.level
     @logger = new_logger(output, prev_level)
+    output
   end
 
   @logger = nil
@@ -175,19 +177,21 @@ module Steep
 
   def self.measure(message, level: :warn)
     start = Time.now
-    yield.tap do
-      time = Time.now - start
-      if level.is_a?(Symbol)
-        level = Logger.const_get(level.to_s.upcase)
-      end
-      self.logger.log(level) { "#{message} took #{time} seconds" }
+    yield
+  ensure
+    time = Time.now - start
+    if level.is_a?(Symbol)
+      level = Logger.const_get(level.to_s.upcase)
     end
+    self.logger.log(level) { "#{message} took #{time} seconds" }
   end
 
   def self.log_error(exn, message: "Unexpected error: #{exn.inspect}")
     Steep.logger.fatal message
-    exn.backtrace.each do |loc|
-      Steep.logger.error "  #{loc}"
+    if backtrace = exn.backtrace
+      backtrace.each do |loc|
+        Steep.logger.error "  #{loc}"
+      end
     end
   end
 
@@ -198,7 +202,9 @@ module Steep
 
     def sample(message)
       start = Time.now
-      yield.tap do
+      begin
+        yield
+      ensure
         time = Time.now - start
         @samples << [message, time]
       end
@@ -220,12 +226,13 @@ module Steep
       if count > 0
         total/count
       else
-        0
+        0.to_f
       end
     end
 
     def percentile(p)
-      slowests([count * p / 100r, 1].max).last&.last || 0
+      c = [count * p / 100.to_r, 1].max or raise
+      slowests(c.to_i).last&.last || 0.to_f
     end
   end
 
@@ -257,7 +264,7 @@ klasses = [
 
 klasses.each do |klass|
   klass.instance_eval do
-    def self.new(*_, **__, &___)
+    def self.new(*_a, **_b, &_c)
       super
     end
   end
@@ -293,7 +300,7 @@ module GCCounter
 
           GC.start(immediate_sweep: true, immediate_mark: true, full_mark: true)
 
-          gceds = []
+          gceds = [] #: Array[[Class, Integer]]
 
           klasses.each do |klass|
             count = ObjectSpace.each_object(klass).count

data/sample/Steepfile

@@ -9,6 +9,7 @@ target :lib do
 
   # 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
   # configure_code_diagnostics do |hash|             # You can setup everything yourself
   #   hash[D::Ruby::NoMethod] = :information
   # end

data/sig/shims/bundler.rbs

@@ -0,0 +1,3 @@
+module Bundler
+  def self.default_gemfile: () -> Pathname
+end

data/sig/shims/language-server_protocol.rbs

@@ -18,16 +18,6 @@ module LanguageServer
     end
 
     module Constant
-      module DiagnosticSeverity
-        ERROR: String
-
-        WARNING: String
-
-        INFORMATION: String
-
-        HINT: String
-      end
-
       module CompletionItemKind
         type t = Integer
 
@@ -87,6 +77,57 @@ module LanguageServer
 
         MARKDOWN: "markdown"
       end
+
+      module DiagnosticSeverity
+        type t = 1 | 2 | 3 | 4
+
+        ERROR: 1
+
+        WARNING: 2
+
+        INFORMATION: 3
+
+        HINT: 4
+      end
+
+      module DiagnosticTag
+        type t = 1 | 2
+
+        UNNECESSARY: 1
+
+        DEPRECATED: 2
+      end
+
+      module SymbolKind
+        FILE: 1
+        MODULE: 2
+        NAMESPACE: 3
+        PACKAGE: 4
+        CLASS: 5
+        METHOD: 6
+        PROPERTY: 7
+        FIELD: 8
+        CONSTRUCTOR: 9
+        ENUM: 10
+        INTERFACE: 11
+        FUNCTION: 12
+        VARIABLE: 13
+        CONSTANT: 14
+        STRING: 15
+        NUMBER: 16
+        BOOLEAN: 17
+        ARRAY: 18
+        OBJECT: 19
+        KEY: 20
+        NULL: 21
+        ENUM_MEMBER: 22
+        STRUCT: 23
+        EVENT: 24
+        OPERATOR: 25
+        TYPE_PARAMETER: 26
+
+        type t = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26
+      end
     end
 
     module Interface
@@ -99,6 +140,8 @@ module LanguageServer
       end
 
       class Position
+        type json = { line: Integer, character: Integer }
+
         include _Base
 
         # 0-origin line number
@@ -114,6 +157,11 @@ module LanguageServer
       class Range
         include _Base
 
+        type json = {
+          start: Position::json,
+          end: Position::json
+        }
+
         attr_reader start: Position
 
         attr_reader end: Position
@@ -122,6 +170,18 @@ module LanguageServer
                       | (Hash[Symbol, untyped]) -> void
       end
 
+      class Location
+        include _Base
+
+        type json = { uri: String, range: Range::json }
+
+        attr_reader uri: String
+
+        attr_reader range: Range
+
+        def initialize: (uri: String, range: Range) -> void
+      end
+
       class MarkupContent
         include _Base
 
@@ -292,6 +352,87 @@ module LanguageServer
 
         def initialize: (signatures: Array[SignatureInformation], ?active_signature: Integer?, ?active_parameter: Integer?) -> void
       end
+
+      class PublishDiagnosticsParams
+        include _Base
+
+        attr_reader uri: String
+
+        attr_reader version: Integer?
+
+        attr_reader diagnostics: Array[Diagnostic]
+
+        def initialize: (uri: String, ?version: Integer?, diagnostics: Array[Diagnostic]) -> void
+      end
+
+      class Diagnostic
+        type json = {
+          range: Range::json,
+          severity: Constant::DiagnosticSeverity::t?,
+          code: Integer | String | nil,
+          codeDescription: CodeDescription::json?,
+          source: String?,
+          message: String,
+          tags: Array[Constant::DiagnosticTag::t]?,
+          relatedInformation: RelatedInformation::json?,
+          data: untyped?
+        }
+
+        attr_reader range: Range
+
+        attr_reader severity: Constant::DiagnosticSeverity::t?
+
+        attr_reader code: Integer | String | nil
+
+        attr_reader code_description: CodeDescription?
+
+        attr_reader source: String?
+
+        attr_reader message: String
+
+        attr_reader tags: Array[Constant::DiagnosticTag::t]?
+
+        attr_reader related_information: RelatedInformation?
+
+        attr_reader data: untyped?
+
+        def initialize: (
+          range: Range,
+          ?severity: Constant::DiagnosticSeverity::t?,
+          ?code: Integer | String | nil,
+          ?code_description: CodeDescription?,
+          ?source: String?,
+          message: String,
+          ?tags: Array[Constant::DiagnosticTag::t]?,
+          ?related_information: RelatedInformation?,
+          ?data: untyped
+        ) -> void
+      end
+
+      class RelatedInformation
+        include _Base
+
+        type json = {
+          location: Location::json,
+          message: String
+        }
+
+        attr_reader location: Location
+
+        attr_reader message: String
+
+        def initialize: (location: Location, message: String) -> void
+      end
+
+      class CodeDescription
+        include _Base
+
+        type json = { href: String }
+
+        attr_reader href: String
+
+        def initialize: (href: String) -> void
+      end
     end
   end
 end

data/sig/shims/parser/nodes.rbs

@@ -19,6 +19,8 @@ module Parser
     end
 
     interface _DefLocation
+      def name: () -> Source::Range
+
       %a{pure} def end: () -> Source::Range?
     end
 
@@ -33,5 +35,213 @@ module Parser
 
       %a{pure} def end: () -> Source::Range
     end
+
+    interface _NamedLocation
+      %a{pure} def name: () -> Source::Range
+    end
+
+    interface _SelectorLocation
+      %a{pure} def selector: () -> Source::Range
+    end
+
+    # ```ruby
+    # if foo then bar else baz end
+    # #^                              => keyword
+    # #      ^^^^                     => begin
+    # #               ^^^^            => else
+    # #                        ^^^    => end
+    # ```
+    #
+    interface _Condition
+      %a{pure} def keyword: () -> Source::Range
+
+      %a{pure} def begin: () -> Source::Range?
+
+      %a{pure} def else: () -> Source::Range?
+
+      %a{pure} def end: () -> Source::Range?
+    end
+
+    interface _Ternary
+      %a{pure} def question: () -> Source::Range
+
+      %a{pure} def colon: () -> Source::Range
+    end
+
+    interface _Variable
+      %a{pure} def name: () -> Source::Range
+
+      %a{pure} def operator: () -> Source::Range?
+    end
+
+    # ```ruby
+    # foo.bar(baz)
+    # #  ^             => dot
+    # #   ^^^          => selector
+    # #      ^         => begin
+    # #          ^     => end
+    #
+    # foo.bar += 1
+    # #  ^             => dot
+    # #   ^^^          => selector
+    # #       ^^       => operator
+    # ```
+    #
+    interface _Send
+      %a{pure} def dot: () -> Source::Range?
+
+      %a{pure} def selector: () -> Source::Range
+
+      %a{pure} def operator: () -> Source::Range?
+
+      %a{pure} def begin: () -> Source::Range?
+
+      %a{pure} def end: () -> Source::Range?
+    end
+
+    # ```ruby
+    # rescue Foo => x then
+    # #^^^^^                => keyword
+    # #          ^^         => assoc
+    # #               ^^^^  => begin
+    # ```
+    interface _RescueBody
+      %a{pure} def keyword: () -> Source::Range
+
+      %a{pure} def assoc: () -> Source::Range?
+
+      %a{pure} def begin: () -> Source::Range?
+    end
+
+    # ```ruby
+    # +1
+    # ^         => operator
+    # ```
+    interface _Operator
+      %a{pure} def operator: () -> Source::Range?
+    end
+
+    # ```ruby
+    # def self.foo(); end
+    # #^^                        => keyword
+    # #       ^                  => operator
+    # #        ^^^               => name
+    # #               ^^^        => end
+    #
+    # def foo = bar
+    # #^^                        => keyword
+    # #   ^^^                    => name
+    # #       ^                  => assignment
+    # ```
+    interface _MethodDefinition
+      %a{pure} def keyword: () -> Source::Range
+
+      %a{pure} def operator: () -> Source::Range?
+
+      %a{pure} def name: () -> Source::Range
+
+      %a{pure} def end: () -> Source::Range?
+
+      %a{pure} def assignment: () -> Source::Range?
+    end
+
+    # ```ruby
+    # when foo then
+    # #^^^             => keyword
+    # #        ^^^^    => begin
+    # ```
+    interface _Keyword
+      %a{pure} def keyword: () -> Source::Range
+
+      %a{pure} def begin: () -> Source::Range?
+
+      %a{pure} def end: () -> Source::Range?
+    end
+
+    # ```ruby
+    # foo[1] += 1
+    # #  ^             => begin
+    # #    ^           => end
+    # #      ^^        => operator
+    # ```
+    interface _Index
+      %a{pure} def begin: () -> Source::Range
+
+      %a{pure} def end: () -> Source::Range
+
+      %a{pure} def operator: () -> Source::Range?
+    end
+
+    # ```ruby
+    # <<FOO                   <= expression
+    #   foo                   <= heredoc_body
+    # FOO                     <= heredoc_end
+    # ```
+    #
+    interface _Heredoc
+      %a{pure} def heredoc_body: () -> Source::Range
+
+      %a{pure} def heredoc_end: () -> Source::Range
+    end
+
+    # ```ruby
+    # for x in [] then ... end
+    # #^^                       => keyword
+    # #     ^^                  => in
+    # #           ^^^^          => begin
+    # #                    ^^^  => end
+    # ```
+    interface _For
+      %a{pure} def keyword: () -> Source::Range
+
+      %a{pure} def in: () -> Source::Range
+
+      %a{pure} def begin: () -> Source::Range?
+
+      %a{pure} def end: () -> Source::Range
+    end
+
+    # ```ruby
+    # class Foo::Bar < Baz; end
+    # #^^^^                       => keyword
+    # #     ^^^^^^^^              => name
+    # #              ^            => operator
+    # #                     ^^^   => end
+    # ```
+    interface _Definition
+      %a{pure} def keyword: () -> Source::Range
+
+      %a{pure} def name: () -> Source::Range
+
+      %a{pure} def operator: () -> Source::Range?
+
+      %a{pure} def end: () -> Source::Range
+    end
+
+    # ```ruby
+    # Foo::Bar += 1
+    # #  ^^                 => double_colon
+    # #    ^^^              => name
+    # #        ^^           => operator
+    # ```
+    #
+    interface _Constant
+      %a{pure} def double_colon: () -> Source::Range?
+
+      %a{pure} def name: () -> Source::Range
+
+      %a{pure} def operator: () -> Source::Range?
+    end
+
+    # ```ruby
+    #   (1)
+    # # ^           => begin
+    # #   ^         => end
+    # ```
+    interface _Collection
+      %a{pure} def begin: () -> Source::Range?
+
+      %a{pure} def end: () -> Source::Range?
+    end
   end
 end

data/sig/shims/parser.rbs

@@ -25,6 +25,16 @@ module Parser
     attr_reader diagnostics: untyped
   end
 
+  class Ruby32
+    def initialize: (untyped builder) -> void
+
+    def parse: (Source::Buffer) -> AST
+
+    def parse_with_comments: (Source::Buffer) -> [AST::Node, Array[Source::Comment]]
+
+    attr_reader diagnostics: untyped
+  end
+
   module Source
     class Buffer
       def initialize: (String file, Integer lineno, source: String) -> void

data/sig/steep/ast/builtin.rbs

@@ -12,9 +12,9 @@ module Steep
 
         def module_type: () -> Types::Name::Singleton
 
-        def instance_type?: (Types::t `type`, ?args: Array[Types::t]?) -> bool
+        def instance_type?: (Types::t `type`, ?args: Array[Types::t]?) -> Types::Name::Instance?
 
-        def module_type?: (Types::t `type`) -> bool
+        def module_type?: (Types::t `type`) -> Types::Name::Singleton?
       end
 
       Object: Type

data/sig/steep/ast/node/type_application.rbs

@@ -12,9 +12,9 @@ module Steep
 
         def initialize: (RBS::Location[untyped, untyped]) -> void
 
-        def types: (RBS::Resolver::context, Types::Factory, Array[Symbol] type_vars) -> (Array[Types::t] | RBS::ParsingError)
+        def types: (RBS::Resolver::context, Subtyping::Check, Array[Symbol] type_vars) -> (Array[Types::t] | RBS::ParsingError | nil)
 
-        def types?: (RBS::Resolver::context, Types::Factory, Array[Symbol] type_vars) -> Array[Types::t]?
+        def types?: (RBS::Resolver::context, Subtyping::Check, Array[Symbol] type_vars) -> Array[Types::t]?
 
         @type_str: String?
         def type_str: () -> String

data/sig/steep/ast/node/type_assertion.rbs

@@ -10,15 +10,21 @@ module Steep
 
         def initialize: (RBS::Location[untyped, untyped]) -> void
 
-        def type: (RBS::Resolver::context, Types::Factory, Array[Symbol] type_vars) -> (Types::t | RBS::ParsingError | nil)
+        def type: (RBS::Resolver::context, Subtyping::Check, Array[Symbol] type_vars) -> (Types::t | RBS::ParsingError | nil)
 
-        def type?: (RBS::Resolver::context, Types::Factory, Array[Symbol] type_vars) -> Types::t?
+        def type?: (RBS::Resolver::context, Subtyping::Check, Array[Symbol] type_vars) -> Types::t?
 
         @type_str: String?
         def type_str: () -> String
 
         def type_location: () -> RBS::Location[untyped, untyped]
 
+        # Returns true if given comment body has a valid type syntax
+        #
+        # This method is used to reject RDoc directives beforehand.
+        #
+        def type_syntax?: () -> bool
+
         def self.parse: (RBS::Location[untyped, untyped]) -> TypeAssertion?
       end
     end

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

@@ -59,7 +59,34 @@ module Steep
         #
         def flatten_union: (t `type`, ?Array[t] acc) -> Array[t]
 
-        def unwrap_optional: (Types::t `type`) -> [Types::t, Types::t]
+        # Partition the type components in union types to truthy ones and falsy ones
+        #
+        # * Returns a pair of *truthy* type and *falsy* type
+        # * The pair may contain `nil` if given type always evaluates to truthy or falsy
+        # * Expand (unfold) the type aliases automatically
+        #
+        # ```ruby
+        # partition_union?(`Integer?`)                          # => [`Integer`, `nil`]
+        # partition_union?(`Integer | String | nil | false`)    # => [`Integer | String`, `nil | false`]
+        # partition_union?(`bool`)                              # => [`bool`, `bool`]
+        # partition_union?(`nil`)                               # => [nil, `nil`]
+        # ```
+        #
+        def partition_union: (Types::t) -> [Types::t?, Types::t?]
+
+        # Returns a type that doesn't have `nil` in the union component
+        #
+        # * Returns `nil` if given type is `nil`
+        # * **Doesn't expand type alias automatically**
+        #
+        # ```ruby
+        # unwrap_optional(`String?`)                               # => `String`
+        # unwrap_optional(`String | Integer | false | nil`)        # => `String | Integer | false`
+        # unwrap_optional(`nil`)                                   # => nil
+        # unwrap_optional(`boolish`)                               # => `boolish`
+        # ```
+        #
+        def unwrap_optional: (Types::t) -> Types::t?
 
         def module_name?: (TypeName type_name) -> bool
 

data/sig/steep/diagnostic/deprecated/else_on_exhaustive_case.rbs

@@ -0,0 +1,13 @@
+module Steep
+  module Diagnostic
+    module Ruby
+      class ElseOnExhaustiveCase < Base
+        attr_reader type: untyped
+
+        def initialize: (node: untyped, type: untyped) -> void
+
+        def header_line: () -> String
+      end
+    end
+  end
+end

data/sig/steep/diagnostic/lsp_formatter.rbs

@@ -1,3 +1,6 @@
+use LanguageServer::Protocol::Constant::DiagnosticSeverity as LSPDiagnosticSeverity
+use LanguageServer::Protocol::Interface::Diagnostic as LSPDiagnostic
+
 module Steep
   module Diagnostic
     class LSPFormatter
@@ -25,9 +28,9 @@ module Steep
 
       def validate_severity: (Class | :default klass, severity?) -> void
 
-      def format: (Diagnostic::Ruby::Base | Diagnostic::Signature::Base) -> Hash[Symbol, untyped]?
+      def format: (Diagnostic::Ruby::Base | Diagnostic::Signature::Base) -> LSPDiagnostic::json?
 
-      def severity_for: (Diagnostic::Ruby::Base | Diagnostic::Signature::Base) -> String?
+      def severity_for: (Diagnostic::Ruby::Base | Diagnostic::Signature::Base) -> LSPDiagnosticSeverity::t?
     end
   end
 end