katakata_irb 0.1.12 → 0.2.1

data/lib/katakata_irb/types.rb

@@ -1,5 +1,4 @@
-require 'rbs'
-require 'rbs/cli'
+# frozen_string_literal: true
 
 module KatakataIrb; end
 module KatakataIrb::Types
@@ -12,10 +11,12 @@ module KatakataIrb::Types
   end
 
   def self.load_rbs_builder
+    require 'rbs'
+    require 'rbs/cli'
     loader = RBS::CLI::LibraryOptions.new.loader
     loader.add path: Pathname('sig')
     RBS::DefinitionBuilder.new env: RBS::Environment.from_loader(loader).resolve_type_names
-  rescue => e
+  rescue LoadError, StandardError => e
     @rbs_load_error = e
     puts "\r\nKatakataIRB failed to initialize RBS::DefinitionBuilder: #{e.class}\r\n"
     puts "See `KatakataIrb::Types.rbs_load_error` for more details.\r\n"
@@ -34,7 +35,7 @@ module KatakataIrb::Types
   def self.rbs_search_method(klass, method_name, singleton)
     klass.ancestors.each do |ancestor|
       name = class_name_of ancestor
-      next unless name
+      next unless name && rbs_builder
       type_name = RBS::TypeName(name).absolute!
       definition = (singleton ? rbs_builder.build_singleton(type_name) : rbs_builder.build_instance(type_name)) rescue nil
       method = definition.methods[method_name] if definition
@@ -77,7 +78,7 @@ module KatakataIrb::Types
         [t, t.klass, false]
       end
     end
-    has_splat = args_types.any? { _1 in Splat }
+    has_splat = args_types.any? { _1.is_a? Splat }
     methods_with_score = receivers.flat_map do |receiver_type, klass, singleton|
       method = rbs_search_method klass, method_name, singleton
       next [] unless method
@@ -91,9 +92,13 @@ module KatakataIrb::Types
         keyreqs = method_type.type.required_keywords
         keyopts = method_type.type.optional_keywords
         keyrest = method_type.type.rest_keywords
-        args = (kwargs_type && keyreqs.empty? && keyopts.empty? && keyrest.nil?) ? args_types + [kwargs_type] : args_types
+        args = args_types
+        if kwargs_type&.any? && keyreqs.empty? && keyopts.empty? && keyrest.nil?
+          kw_value_type = UnionType[*kwargs_type.values]
+          args += [InstanceType.new(Hash, K: SYMBOL, V: kw_value_type)]
+        end
         if has_splat
-          score += 1 if args.count { !(_1 in Splat) } <= reqs.size + opts.size + trailings.size
+          score += 1 if args.count { !(_1.is_a? Splat) } <= reqs.size + opts.size + trailings.size
         elsif reqs.size + trailings.size <= args.size && (rest || args.size <= reqs.size + opts.size + trailings.size)
           score += 2
           centers = args[reqs.size...-trailings.size]
@@ -202,7 +207,7 @@ module KatakataIrb::Types
     def nonnillable() = self
     def rbs_methods
       name = KatakataIrb::Types.class_name_of(@klass)
-      return {} unless name
+      return {} unless name && KatakataIrb::Types.rbs_builder
 
       type_name = RBS::TypeName(name).absolute!
       KatakataIrb::Types.rbs_builder.build_instance(type_name).methods rescue {}
@@ -323,6 +328,11 @@ module KatakataIrb::Types
 
   BOOLEAN = UnionType[TRUE, FALSE]
 
+  def self.array_of(*types)
+    type = types.size >= 2 ? UnionType[*types] : types.first || OBJECT
+    InstanceType.new Array, Elem: type
+  end
+
   def self.from_rbs_type(return_type, self_type, extra_vars = {})
     case return_type
     when RBS::Types::Bases::Self
@@ -365,11 +375,11 @@ module KatakataIrb::Types
     when RBS::Types::Variable
       if extra_vars.key? return_type.name
         extra_vars[return_type.name]
-      elsif self_type in InstanceType
+      elsif self_type.is_a? InstanceType
         self_type.params[return_type.name] || OBJECT
-      elsif self_type in UnionType
+      elsif self_type.is_a? UnionType
         types = self_type.types.filter_map do |t|
-          t.params[return_type.name] if t in InstanceType
+          t.params[return_type.name] if t.is_a? InstanceType
         end
         UnionType[*types]
       else
@@ -403,6 +413,10 @@ module KatakataIrb::Types
     end
   end
 
+  def self.method_return_bottom?(method)
+    method.type.return_type.is_a? RBS::Types::Bases::Bottom
+  end
+
   def self.match_free_variables(vars, types, values)
     accumulator = {}
     types.zip values do |t, v|

data/lib/katakata_irb/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module KatakataIrb
-  VERSION = "0.1.12"
+  VERSION = "0.2.1"
 end

data/lib/katakata_irb.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'katakata_irb/version'
 require 'katakata_irb/completor'
 require 'katakata_irb/types'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: katakata_irb
 version: !ruby/object:Gem::Version
-  version: 0.1.12
+  version: 0.2.1
 platform: ruby
 authors:
 - tompng
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-10-14 00:00:00.000000000 Z
+date: 2023-10-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: irb
@@ -38,6 +38,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.3.0
+- !ruby/object:Gem::Dependency
+  name: prism
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.14.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.14.0
 - !ruby/object:Gem::Dependency
   name: rbs
   requirement: !ruby/object:Gem::Requirement
@@ -68,9 +82,8 @@ files:
 - katakata_irb.gemspec
 - lib/katakata_irb.rb
 - lib/katakata_irb/completor.rb
-- lib/katakata_irb/nesting_parser.rb
 - lib/katakata_irb/scope.rb
-- lib/katakata_irb/type_simulator.rb
+- lib/katakata_irb/type_analyzer.rb
 - lib/katakata_irb/types.rb
 - lib/katakata_irb/version.rb
 - sig/katakata_irb.rbs

data/lib/katakata_irb/nesting_parser.rb

@@ -1,257 +0,0 @@
-module KatakataIrb::NestingParser
-  ERROR_TOKENS = %i[
-    on_parse_error
-    compile_error
-    on_assign_error
-    on_alias_error
-    on_class_name_error
-    on_param_error
-  ]
-
-  def self.tokenize(code)
-    verbose, $VERBOSE = $VERBOSE, nil
-    tokens = Ripper::Lexer.new(code).scan.reject { ERROR_TOKENS.include? _1.event }
-    KatakataIrb::NestingParser.interpolate_ripper_ignored_tokens code, tokens
-  ensure
-    $VERBOSE = verbose
-  end
-
-  def self.interpolate_ripper_ignored_tokens(code, tokens)
-    line_positions = code.lines.reduce([0]) { _1 << _1.last + _2.bytesize }
-    prev_byte_pos = 0
-    interpolated = []
-    prev_line = 1
-    event = :on_ignored_by_ripper
-    tokens.each do |t|
-      line, col = t.pos
-      byte_pos = line_positions[line - 1] + col
-      if prev_byte_pos < byte_pos
-        tok = code.byteslice(prev_byte_pos...byte_pos)
-        pos = [prev_line, prev_byte_pos - line_positions[prev_line - 1]]
-        interpolated << Ripper::Lexer::Elem.new(pos, event, tok, 0)
-        prev_line += tok.count("\n")
-      end
-      interpolated << t
-      prev_byte_pos = byte_pos + t.tok.bytesize
-      prev_line += t.tok.count("\n")
-    end
-    if prev_byte_pos < code.bytesize
-      tok = code.byteslice(prev_byte_pos..)
-      pos = [prev_line, prev_byte_pos - line_positions[prev_line - 1]]
-      interpolated << Ripper::Lexer::Elem.new(pos, event, tok, 0)
-    end
-    interpolated
-  end
-
-  IGNORE_TOKENS = %i[on_sp on_ignored_nl on_comment on_embdoc_beg on_embdoc on_embdoc_end]
-
-  # Scan each token and call the given block with array of token and other information for parsing
-  def self.scan_opens(tokens)
-    opens = []
-    pending_heredocs = []
-    first_token_on_line = true
-    tokens.each do |t|
-      skip = false
-      last_tok, state, args = opens.last
-      case state
-      when :in_unquoted_symbol
-        unless IGNORE_TOKENS.include?(t.event)
-          opens.pop
-          skip = true
-        end
-      when :in_lambda_head
-        opens.pop if t.event == :on_tlambeg || (t.event == :on_kw && t.tok == 'do')
-      when :in_method_head
-        unless IGNORE_TOKENS.include?(t.event)
-          next_args = []
-          body = nil
-          if args.include?(:receiver)
-            case t.event
-            when :on_lparen, :on_ivar, :on_gvar, :on_cvar
-              # def (receiver). | def @ivar. | def $gvar. | def @@cvar.
-              next_args << :dot
-            when :on_kw
-              case t.tok
-              when 'self', 'true', 'false', 'nil'
-                # def self(arg) | def self.
-                next_args.push(:arg, :dot)
-              else
-                # def if(arg)
-                skip = true
-                next_args << :arg
-              end
-            when :on_op, :on_backtick
-              # def +(arg)
-              skip = true
-              next_args << :arg
-            when :on_ident, :on_const
-              # def a(arg) | def a.
-              next_args.push(:arg, :dot)
-            end
-          end
-          if args.include?(:dot)
-            # def receiver.name
-            next_args << :name if t.event == :on_period || (t.event == :on_op && t.tok == '::')
-          end
-          if args.include?(:name)
-            if %i[on_ident on_const on_op on_kw on_backtick].include?(t.event)
-              # def name(arg) | def receiver.name(arg)
-              next_args << :arg
-              skip = true
-            end
-          end
-          if args.include?(:arg)
-            case t.event
-            when :on_nl, :on_semicolon
-              # def recever.f;
-              body = :normal
-            when :on_lparen
-              # def recever.f()
-              next_args << :eq
-            else
-              if t.event == :on_op && t.tok == '='
-                # def receiver.f =
-                body = :oneliner
-              else
-                # def recever.f arg
-                next_args << :arg_without_paren
-              end
-            end
-          end
-          if args.include?(:eq)
-            if t.event == :on_op && t.tok == '='
-              body = :oneliner
-            else
-              body = :normal
-            end
-          end
-          if args.include?(:arg_without_paren)
-            if %i[on_semicolon on_nl].include?(t.event)
-              # def f a;
-              body = :normal
-            else
-              # def f a, b
-              next_args << :arg_without_paren
-            end
-          end
-          if body == :oneliner
-            opens.pop
-          elsif body
-            opens[-1] = [last_tok, nil]
-          else
-            opens[-1] = [last_tok, :in_method_head, next_args]
-          end
-        end
-      when :in_for_while_until_condition
-        if t.event == :on_semicolon || t.event == :on_nl || (t.event == :on_kw && t.tok == 'do')
-          skip = true if t.event == :on_kw && t.tok == 'do'
-          opens[-1] = [last_tok, nil]
-        end
-      when :in_block_head
-        if t.event == :on_op && t.tok == '|'
-          opens[-1] = [last_tok, nil]
-          opens << [t, :in_block_args]
-        elsif !IGNORE_TOKENS.include?(t.event)
-          opens[-1] = [last_tok, nil]
-        end
-      when :in_block_args
-        if t.event == :on_op && t.tok == '|' && t.state.allbits?(Ripper::EXPR_BEG)
-          opens.pop
-          skip = true
-        end
-      end
-
-      unless skip
-        case t.event
-        when :on_kw
-          case t.tok
-          when 'do'
-            opens << [t, :in_block_head]
-          when 'begin', 'class', 'module', 'case'
-            opens << [t, nil]
-          when 'end'
-            opens.pop
-          when 'def'
-            opens << [t, :in_method_head, [:receiver, :name]]
-          when 'if', 'unless'
-            unless t.state.allbits?(Ripper::EXPR_LABEL)
-              opens << [t, nil]
-            end
-          when 'while', 'until'
-            unless t.state.allbits?(Ripper::EXPR_LABEL)
-              opens << [t, :in_for_while_until_condition]
-            end
-          when 'ensure', 'rescue'
-            unless t.state.allbits?(Ripper::EXPR_LABEL)
-              opens.pop
-              opens << [t, nil]
-            end
-          when 'elsif', 'else', 'when'
-            opens.pop
-            opens << [t, nil]
-          when 'for'
-            opens << [t, :in_for_while_until_condition]
-          when 'in'
-            if last_tok&.event == :on_kw && %w[case in].include?(last_tok.tok) && first_token_on_line
-              opens.pop
-              opens << [t, nil]
-            end
-          end
-        when :on_lbrace
-          if t.state.allbits?(Ripper::EXPR_LABEL)
-            opens << [t, nil]
-          else
-            opens << [t, :in_block_head]
-          end
-        when :on_tlambda
-          opens << [t, :in_lambda_head]
-        when :on_lparen, :on_lbracket, :on_tlambeg, :on_embexpr_beg, :on_embdoc_beg
-          opens << [t, nil]
-        when :on_rparen, :on_rbracket, :on_rbrace, :on_embexpr_end, :on_embdoc_end
-          opens.pop
-        when :on_heredoc_beg
-          pending_heredocs << t
-        when :on_heredoc_end
-          opens.pop
-        when :on_backtick
-          opens << [t, nil] if t.state.allbits?(Ripper::EXPR_BEG)
-        when :on_tstring_beg, :on_words_beg, :on_qwords_beg, :on_symbols_beg, :on_qsymbols_beg, :on_regexp_beg
-          opens << [t, nil]
-        when :on_tstring_end, :on_regexp_end, :on_label_end
-          opens.pop
-        when :on_symbeg
-          if t.tok == ':'
-            opens << [t, :in_unquoted_symbol]
-          else
-            opens << [t, nil]
-          end
-        when :on_op
-          case t.tok
-          when '?'
-            # opening of `cond ? value : value``
-            opens << [t, nil]
-          when ':'
-            # closing of `cond ? value : value``
-            opens.pop
-          end
-        end
-      end
-      if t.event == :on_nl || t.event == :on_semicolon
-        first_token_on_line = true
-      elsif t.event != :on_sp
-        first_token_on_line = false
-      end
-      if pending_heredocs.any? && t.tok.include?("\n")
-        pending_heredocs.reverse_each { |t| opens << [t, nil] }
-        pending_heredocs = []
-      end
-      yield t, opens if block_given?
-    end
-    opens.map(&:first) + pending_heredocs.reverse
-  end
-
-  def self.open_tokens(tokens)
-    # scan_opens without block will return a list of open tokens at last token position
-    scan_opens(tokens)
-  end
-end