steep 1.2.1 → 1.3.0.pre.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 350eb85d965ebe0f830b76a4866e2380fbc03d19bdafb5c683e5cf426fff35f4
-  data.tar.gz: 6be02c8f8628ea4a4c3f701fb4066d678a0237c3079245e2738380a41975dff0
+  metadata.gz: 639a97319d661c777702365209eaf5a6ea2632723a509331a03f6f1ef3926148
+  data.tar.gz: fb6061b52a09fb97c907abff4f69d6c9267eef1c9a3af52fa87fffda9de5d1f0
 SHA512:
-  metadata.gz: 8d18a11bf1ee0e927651727dde99a9db70e99669c91b37e361b0c4cf1dff6d0b4aab914a63480a4db8477fe49694ab4ba74e99aad4b27f6df64e664ec3d53ca2
-  data.tar.gz: 0cf526b1068660ffc759b41f1f197bf85b4f1590619bd2198b6f5fb5e770d26a2c617d53d00aa475cdacfd154eab1fcc1de5ff394da4ef804873b29f5fd9794a
+  metadata.gz: 232ec5b779c018aa9824318e003cd60e3ec3691297903337bb414fff87e757daaacfda2d94fb0c751538dcad194763ad6cb5b072156686bd450d5292d490a2e6
+  data.tar.gz: b322f5568a1fe5cbc0693a01a7be50d9860e056a9f69325e6c55a9322f2d32f7d1d0889d19e45576ca6f3f9afde9649747d9d02a0e251702f94cd27bf5fae27c

data/CHANGELOG.md

@@ -2,6 +2,34 @@
 
 ## master
 
+## 1.3.0.pre.2 (2022-11-23)
+
+### Type checker core
+
+* Add missing `#level` method ([\#671](https://github.com/soutaro/steep/pull/671))
+* Cache `constant_resolver` among files in a target([\#673](https://github.com/soutaro/steep/pull/673))
+* Early return from type checking overloads ([\#674](https://github.com/soutaro/steep/pull/674))
+
+### Commandline tool
+
+* Spawn worker processes if `--steep-command` is specified ([\#672](https://github.com/soutaro/steep/pull/672))
+
+## 1.3.0.pre.1 (2022-11-22)
+
+### Type checker core
+
+* Add type assertion syntax ([#665](https://github.com/soutaro/steep/pull/665))
+* Add type application syntax ([#670](https://github.com/soutaro/steep/pull/670))
+
+### Commandline tool
+
+* Fork when available for quicker startup ([#664](https://github.com/soutaro/steep/pull/664))
+
+### Miscellaneous
+
+* Fixes for some RBS errors within steep gem ([#668](https://github.com/soutaro/steep/pull/668))
+* Upgrade to RBS 2.8 (pre) ([#669](https://github.com/soutaro/steep/pull/669))
+
 ## 1.2.1 (2022-10-22)
 
 ### Type checker core

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    steep (1.2.1)
+    steep (1.3.0.pre.2)
       activesupport (>= 5.1)
       csv (>= 3.0.9)
       fileutils (>= 1.1.0)
@@ -12,7 +12,7 @@ PATH
       parallel (>= 1.0.0)
       parser (>= 3.1)
       rainbow (>= 2.2.2, < 4.0)
-      rbs (>= 2.7.0)
+      rbs (>= 2.8.0.pre)
       securerandom (>= 0.1)
       strscan (>= 1.0.0)
       terminal-table (>= 2, < 4)
@@ -54,11 +54,11 @@ GEM
     rb-fsevent (0.11.2)
     rb-inotify (0.10.1)
       ffi (~> 1.0)
-    rbs (2.7.0)
+    rbs (2.8.0.pre.1)
     ruby-debug-ide (0.7.3)
       rake (>= 0.8.1)
     securerandom (0.2.0)
-    stackprof (0.2.21)
+    stackprof (0.2.22)
     strscan (3.0.4)
     terminal-table (3.0.2)
       unicode-display_width (>= 1.1.1, < 3)

data/Gemfile.steep

@@ -1,4 +1,4 @@
 source "https://rubygems.org"
 
 gem 'steep', '~> 1.2.0'
-gem "rbs"
+gem "rbs", '~> 2.8.0.pre'

data/Gemfile.steep.lock

@@ -8,13 +8,17 @@ GEM
       tzinfo (~> 2.0)
     ast (2.4.2)
     concurrent-ruby (1.1.10)
+    csv (3.2.5)
     ffi (1.15.5)
+    fileutils (1.6.0)
     i18n (1.12.0)
       concurrent-ruby (~> 1.0)
+    json (2.6.2)
     language_server-protocol (3.17.0.1)
     listen (3.7.1)
       rb-fsevent (~> 0.10, >= 0.10.3)
       rb-inotify (~> 0.9, >= 0.9.10)
+    logger (1.5.1)
     minitest (5.16.3)
     parallel (1.22.1)
     parser (3.1.2.1)
@@ -23,18 +27,24 @@ GEM
     rb-fsevent (0.11.2)
     rb-inotify (0.10.1)
       ffi (~> 1.0)
-    rbs (2.7.0)
+    rbs (2.8.0.pre.1)
     securerandom (0.2.0)
-    steep (1.2.0)
+    steep (1.2.1)
       activesupport (>= 5.1)
+      csv (>= 3.0.9)
+      fileutils (>= 1.1.0)
+      json (>= 2.1.0)
       language_server-protocol (>= 3.15, < 4.0)
       listen (~> 3.0)
+      logger (>= 1.3.0)
       parallel (>= 1.0.0)
       parser (>= 3.1)
       rainbow (>= 2.2.2, < 4.0)
       rbs (>= 2.7.0)
       securerandom (>= 0.1)
+      strscan (>= 1.0.0)
       terminal-table (>= 2, < 4)
+    strscan (3.0.4)
     terminal-table (3.0.2)
       unicode-display_width (>= 1.1.1, < 3)
     tzinfo (2.0.5)
@@ -45,7 +55,7 @@ PLATFORMS
   arm64-darwin-21
 
 DEPENDENCIES
-  rbs
+  rbs (~> 2.8.0.pre)
   steep (~> 1.2.0)
 
 BUNDLED WITH

data/Steepfile

@@ -10,7 +10,6 @@ target :app do
     hash[D::Ruby::MethodDefinitionMissing] = :hint
   end
 
-  signature "../rbs/sig", "../rbs/stdlib/rdoc/0"
   library(
     "set",
     "pathname",

data/bin/steep-prof

@@ -2,7 +2,7 @@
 
 require "stackprof"
 
-mode = (ENV["STEEP_STACKPROF_MODE"] || :wall).to_sym
+mode = (ENV["STEEP_STACKPROF_MODE"] || :cpu).to_sym
 out = ENV["STEEP_STACKPROF_OUT"] || "tmp/stackprof-#{mode}-steep.dump"
 interval = ENV["STEEP_STACKPROF_INTERVAL"]&.to_i || 1000
 

data/lib/steep/annotation_parser.rb

@@ -27,7 +27,7 @@ module Steep
         message = case exn
                   when RBS::ParsingError
                     Diagnostic::Signature::SyntaxError.parser_syntax_error_message(exn)
-                  else
+                  when Exception
                     exn.message
                   end
 
@@ -45,16 +45,10 @@ module Steep
       factory.type(RBS::Parser.parse_type(string))
     end
 
-    # @type ${keyword} ${name}: ${type}
-    # Example: @type const Foo::Bar: String
-    #          @type var xyzzy: Array[String]
     def keyword_subject_type(keyword, name)
       /@type\s+#{keyword}\s+(?<name>#{name})#{COLON}#{TYPE}/
     end
 
-    # @type ${keyword}: ${type}
-    # Example: @type break: String
-    #          @type self: Foo
     def keyword_and_type(keyword)
       /@type\s+#{keyword}#{COLON}#{TYPE}/
     end
@@ -63,8 +57,9 @@ module Steep
       case src
       when keyword_subject_type("var", VAR_NAME)
         Regexp.last_match.yield_self do |match|
-          name = match[:name]
-          type = match[:type]
+          match or raise
+          name = match[:name] or raise
+          type = match[:type] or raise
 
           AST::Annotation::VarType.new(name: name.to_sym,
                                        type: parse_type(type),
@@ -73,8 +68,9 @@ module Steep
 
       when keyword_subject_type("method", METHOD_NAME)
         Regexp.last_match.yield_self do |match|
-          name = match[:name]
-          type = match[:type]
+          match or raise
+          name = match[:name] or raise
+          type = match[:type] or raise
 
           method_type = factory.method_type(RBS::Parser.parse_method_type(type), method_decls: Set[])
 
@@ -85,16 +81,18 @@ module Steep
 
       when keyword_subject_type("const", CONST_NAME)
         Regexp.last_match.yield_self do |match|
-          name = match[:name]
-          type = parse_type(match[:type])
+          match or raise
+          name = match[:name] or raise
+          type = parse_type(match[:type] || raise)
 
           AST::Annotation::ConstType.new(name: TypeName(name), type: type, location: location)
         end
 
       when keyword_subject_type("ivar", IVAR_NAME)
         Regexp.last_match.yield_self do |match|
-          name = match[:name]
-          type = parse_type(match[:type])
+          match or raise
+          name = match[:name] or raise
+          type = parse_type(match[:type] || raise)
 
           AST::Annotation::IvarType.new(name: name.to_sym,
                                          type: type,
@@ -103,51 +101,58 @@ module Steep
 
       when keyword_and_type("return")
         Regexp.last_match.yield_self do |match|
-          type = parse_type(match[:type])
+          match or raise
+          type = parse_type(match[:type] || raise)
           AST::Annotation::ReturnType.new(type: type, location: location)
         end
 
       when keyword_and_type("block")
         Regexp.last_match.yield_self do |match|
-          type = parse_type(match[:type])
+          match or raise
+          type = parse_type(match[:type] || raise)
           AST::Annotation::BlockType.new(type: type, location: location)
         end
 
       when keyword_and_type("self")
         Regexp.last_match.yield_self do |match|
-          type = parse_type(match[:type])
+          match or raise
+          type = parse_type(match[:type] || raise)
           AST::Annotation::SelfType.new(type: type, location: location)
         end
 
       when keyword_and_type("instance")
         Regexp.last_match.yield_self do |match|
-          type = parse_type(match[:type])
+          match or raise
+          type = parse_type(match[:type] || raise)
           AST::Annotation::InstanceType.new(type: type, location: location)
         end
 
       when keyword_and_type("module")
         Regexp.last_match.yield_self do |match|
-          type = parse_type(match[:type])
+          match or raise
+          type = parse_type(match[:type] || raise)
           AST::Annotation::ModuleType.new(type: type, location: location)
         end
 
       when keyword_and_type("break")
         Regexp.last_match.yield_self do |match|
-          type = parse_type(match[:type])
+          match or raise
+          type = parse_type(match[:type] || raise)
           AST::Annotation::BreakType.new(type: type, location: location)
         end
 
       when /@dynamic\s+(?<names>(#{DYNAMIC_NAME}\s*,\s*)*#{DYNAMIC_NAME})/
         Regexp.last_match.yield_self do |match|
-          names = match[:names].split(/\s*,\s*/)
+          match or raise
+          names = (match[:names] || raise).split(/\s*,\s*/)
 
           AST::Annotation::Dynamic.new(
             names: names.map {|name|
-              case name
-              when /^self\./
-                AST::Annotation::Dynamic::Name.new(name: name[5..].to_sym, kind: :module)
-              when /^self\?\./
-                AST::Annotation::Dynamic::Name.new(name: name[6..].to_sym, kind: :module_instance)
+              case
+              when name.delete_prefix!("self.")
+                AST::Annotation::Dynamic::Name.new(name: name.to_sym, kind: :module)
+              when name.delete_prefix!("self?.")
+                AST::Annotation::Dynamic::Name.new(name: name.to_sym, kind: :module_instance)
               else
                 AST::Annotation::Dynamic::Name.new(name: name.to_sym, kind: :instance)
               end
@@ -158,7 +163,8 @@ module Steep
 
       when /@implements\s+(?<name>#{CONST_NAME})#{TYPE_PARAMS}$/
         Regexp.last_match.yield_self do |match|
-          type_name = TypeName(match[:name])
+          match or raise
+          type_name = TypeName(match[:name] || raise)
           params = match[:params]&.yield_self {|params| params.split(/,/).map {|param| param.strip.to_sym } } || []
 
           name = AST::Annotation::Implements::Module.new(name: type_name, args: params)

data/lib/steep/ast/annotation.rb

@@ -1,10 +1,19 @@
 module Steep
   module AST
     module Annotation
+      module Located
+        attr_reader :location
+
+        def line
+          location&.start_line
+        end
+      end
+
       class Named
+        include Located
+
         attr_reader :name
         attr_reader :type
-        attr_reader :location
 
         def initialize(name:, type:, location: nil)
           @name = name
@@ -20,9 +29,9 @@ module Steep
       end
 
       class Typed
+        include Located
+
         attr_reader :type
-        attr_reader :annotation
-        attr_reader :location
 
         def initialize(type:, location: nil)
           @type = type
@@ -68,7 +77,8 @@ module Steep
           end
         end
 
-        attr_reader :location
+        include Located
+
         attr_reader :name
 
         def initialize(name:, location: nil)
@@ -108,7 +118,8 @@ module Steep
           end
         end
 
-        attr_reader :location
+        include Located
+
         attr_reader :names
 
         def initialize(names:, location: nil)

data/lib/steep/ast/node/type_application.rb

@@ -0,0 +1,74 @@
+module Steep
+  module AST
+    module Node
+      class TypeApplication
+        attr_reader :location
+
+        def initialize(location)
+          @location = location
+        end
+
+        def node
+          @node || raise
+        end
+
+        def set_node(node)
+          @node = node
+        end
+
+        def line
+          location.start_line
+        end
+
+        def source
+          location.source
+        end
+
+        def types(context, factory, type_vars)
+          # @type var types: Array[Types::t]
+          types = []
+
+          loc = type_location
+
+          while true
+            ty = RBS::Parser.parse_type(loc.buffer, range: loc.range, variables: type_vars) or break
+            ty = factory.type(ty)
+            types << factory.absolute_type(ty, context: context)
+
+            match = RBS::Location.new(loc.buffer, ty.location.end_pos, type_location.end_pos).source.match(/\A\s*,\s*/) or break
+            offset = match.length
+            loc = RBS::Location.new(loc.buffer, ty.location.end_pos + offset, type_location.end_pos)
+          end
+
+          types
+        rescue ::RBS::ParsingError => exn
+          exn
+        end
+
+        def types?(context, factory, type_vars)
+          case types = types(context, factory, type_vars)
+          when RBS::ParsingError
+            nil
+          else
+            types
+          end
+        end
+
+        def type_str
+          @type_str ||= source.delete_prefix("$").lstrip
+        end
+
+        def type_location
+          offset = source.size - type_str.size
+          RBS::Location.new(location.buffer, location.start_pos + offset, location.end_pos)
+        end
+
+        def self.parse(location)
+          if location.source =~/\A\$\s*(.+)/
+            TypeApplication.new(location)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/steep/ast/node/type_assertion.rb

@@ -0,0 +1,56 @@
+module Steep
+  module AST
+    module Node
+      class TypeAssertion
+        attr_reader :location
+
+        def initialize(location)
+          @location = location
+        end
+
+        def source
+          location.source
+        end
+
+        def line
+          location.start_line
+        end
+
+        def type(context, factory, type_vars)
+          if ty = RBS::Parser.parse_type(type_location.buffer, range: type_location.range, variables: type_vars)
+            ty = factory.type(ty)
+            factory.absolute_type(ty, context: context)
+          else
+            nil
+          end
+        rescue ::RBS::ParsingError => exn
+          exn
+        end
+
+        def type?(context, factory, type_vars)
+          case type = type(context, factory, type_vars)
+          when RBS::ParsingError
+            nil
+          else
+            type
+          end
+        end
+
+        def type_str
+          @type_str ||= source.delete_prefix(":").lstrip
+        end
+
+        def type_location
+          offset = source.size - type_str.size
+          RBS::Location.new(location.buffer, location.start_pos + offset, location.end_pos)
+        end
+
+        def self.parse(location)
+          if location.source =~/\A:\s*(.+)/
+            TypeAssertion.new(location)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/steep/ast/types/factory.rb

@@ -37,7 +37,11 @@ module Steep
         end
 
         def type(type)
-          ty = type_cache[type] and return ty
+          unless type.location
+            if ty = type_cache[type]
+              return ty
+            end
+          end
 
           type_cache[type] =
             case type

data/lib/steep/ast/types/helper.rb

@@ -4,12 +4,13 @@ module Steep
       module Helper
         module ChildrenLevel
           def level_of_children(children)
-            children.map(&:level).sort {|a, b| b.size <=> a.size }.inject() do |a, b|
-              a.zip(b).map do |(x, y)|
+            levels = children.map(&:level)
+            children.map(&:level).sort {|a, b| (b.size <=> a.size) || 0 }.inject() do |a, b|
+              a.zip(b).map do |x, y|
                 if x && y
                   x + y
                 else
-                  x || y
+                  x || y || raise
                 end
               end
             end || []

data/lib/steep/ast/types/logic.rb

@@ -28,6 +28,10 @@ module Steep
           def to_s
             "<% #{self.class} %>"
           end
+
+          def level
+            [0]
+          end
         end
 
         class Not < Base

data/lib/steep/diagnostic/helper.rb

@@ -2,7 +2,8 @@ module Steep
   module Diagnostic
     module Helper
       def error_name
-        self.class.name.split(/::/).last
+        name = self.class.name or raise
+        name.split(/::/).last or raise
       end
 
       def full_message

data/lib/steep/diagnostic/lsp_formatter.rb

@@ -41,11 +41,13 @@ module Steep
         severity = severity_for(diagnostic)
 
         if severity
+          range = diagnostic.location&.as_lsp_range or raise
+
           LSP::Interface::Diagnostic.new(
             message: diagnostic.full_message,
             code: diagnostic.diagnostic_code,
             severity: severity,
-            range: diagnostic.location.as_lsp_range
+            range: range
           ).to_hash
         end
       end

data/lib/steep/diagnostic/ruby.rb

@@ -773,6 +773,65 @@ module Steep
         end
       end
 
+      class FalseAssertion < Base
+        attr_reader :node, :assertion_type, :node_type
+
+        def initialize(node:, assertion_type:, node_type:)
+          super(node: node)
+          @assertion_type = assertion_type
+          @node_type = node_type
+        end
+
+        def header_line
+          "Assertion cannot hold: no relationship between infered type (`#{node_type.to_s}`) and asserted type (`#{assertion_type.to_s}`)"
+        end
+      end
+
+      class UnexpectedTypeArgument < Base
+        attr_reader :type_arg, :method_type
+
+        def initialize(type_arg:, method_type:)
+          super(node: nil, location: type_arg.location)
+          @type_arg = type_arg
+          @method_type = method_type
+        end
+
+        def header_line
+          "Unexpected type arg is given to method type `#{method_type.to_s}`"
+        end
+      end
+
+      class InsufficientTypeArgument < Base
+        attr_reader :type_args, :method_type
+
+        def initialize(node:, type_args:, method_type:)
+          super(node: node)
+          @type_args = type_args
+          @method_type = method_type
+        end
+
+        def header_line
+          "Requires #{method_type.type_params.size} types, but #{type_args.size} given: `#{method_type.to_s}`"
+        end
+      end
+
+      class TypeArgumentMismatchError < Base
+        attr_reader :type_argument, :type_parameter, :result
+
+        def initialize(type_arg:, type_param:, result:)
+          super(node: nil, location: type_arg.location)
+          @type_argument = type_arg
+          @type_parameter = type_param
+          @result = result
+        end
+
+        include ResultPrinter
+
+        def header_line
+          "Cannot pass a type `#{type_argument}` as a type parameter `#{type_parameter.to_s}`"
+        end
+      end
+
       ALL = ObjectSpace.each_object(Class).with_object([]) do |klass, array|
         if klass < Base
           array << klass
@@ -781,24 +840,29 @@ module Steep
 
       def self.all_error
         @all_error ||= ALL.each.with_object({}) do |klass, hash|
+          # @type var hash: Hash[singleton(Base), LSPFormatter::severity]
           hash[klass] = LSPFormatter::ERROR
         end.freeze
       end
 
       def self.default
-        @default ||= all_error.merge(
+        @default ||= _ = all_error.merge(
           {
             ImplicitBreakValueMismatch => :warning,
             FallbackAny => :information,
             ElseOnExhaustiveCase => :warning,
             UnknownConstant => :warning,
-            MethodDefinitionMissing => :information
+            MethodDefinitionMissing => :information,
+            FalseAssertion => :information,
+            UnexpectedTypeArgument => :information,
+            InsufficientTypeArgument => :information,
+            UnexpectedTypeArgument => :information
           }
         ).freeze
       end
 
       def self.strict
-        @strict ||= all_error.merge(
+        @strict ||= _ = all_error.merge(
           {
             NoMethod => nil,
             ImplicitBreakValueMismatch => nil,
@@ -811,7 +875,7 @@ module Steep
       end
 
       def self.lenient
-        @lenient ||= all_error.merge(
+        @lenient ||= _ = all_error.merge(
           {
             NoMethod => nil,
             ImplicitBreakValueMismatch => nil,
@@ -819,7 +883,8 @@ module Steep
             ElseOnExhaustiveCase => nil,
             UnknownConstant => nil,
             MethodDefinitionMissing => nil,
-            UnexpectedJump => nil
+            UnexpectedJump => nil,
+            FalseAssertion => :hint
           }
         ).freeze
       end