typeprof 0.15.0 → 0.20.0

data/lib/typeprof/method.rb

@@ -14,6 +14,8 @@ module TypeProf
       @pub_meth = pub_meth
     end
 
+    attr_reader :iseq
+
     def do_send(recv, mid, aargs, caller_ep, caller_env, scratch, &ctn)
       recv = recv.base_type while recv.respond_to?(:base_type)
       recv = scratch.globalize_type(recv, caller_env, caller_ep)
@@ -35,7 +37,7 @@ module TypeProf
       locals.each_with_index do |ty, i|
         alloc_site2 = alloc_site.add_id(i)
         # nenv is top-level, so it is okay to call Type#localize directly
-        nenv, ty = ty.localize(nenv, alloc_site2, Config.options[:type_depth_limit])
+        nenv, ty = ty.localize(nenv, alloc_site2, Config.current.options[:type_depth_limit])
         nenv = nenv.local_update(i, ty)
       end
 
@@ -95,14 +97,14 @@ module TypeProf
       idx = 0
       msig.lead_tys.each_with_index do |ty, i|
         alloc_site2 = alloc_site.add_id(idx += 1)
-        ty = ty.substitute(cur_subst, Config.options[:type_depth_limit]).remove_type_vars
+        ty = ty.substitute(cur_subst, Config.current.options[:type_depth_limit]).remove_type_vars
         nenv, ty = scratch.localize_type(ty, nenv, callee_ep, alloc_site2)
         nenv = nenv.local_update(i, ty)
       end
       if msig.opt_tys
         msig.opt_tys.each_with_index do |ty, i|
           alloc_site2 = alloc_site.add_id(idx += 1)
-          ty = ty.substitute(cur_subst, Config.options[:type_depth_limit]).remove_type_vars
+          ty = ty.substitute(cur_subst, Config.current.options[:type_depth_limit]).remove_type_vars
           nenv, ty = scratch.localize_type(ty, nenv, callee_ep, alloc_site2)
           nenv = nenv.local_update(lead_num + i, ty)
         end
@@ -110,14 +112,14 @@ module TypeProf
       if msig.rest_ty
         alloc_site2 = alloc_site.add_id(idx += 1)
         ty = Type::Array.new(Type::Array::Elements.new([], msig.rest_ty), Type::Instance.new(Type::Builtin[:ary]))
-        ty = ty.substitute(cur_subst, Config.options[:type_depth_limit]).remove_type_vars
+        ty = ty.substitute(cur_subst, Config.current.options[:type_depth_limit]).remove_type_vars
         nenv, rest_ty = scratch.localize_type(ty, nenv, callee_ep, alloc_site2)
         nenv = nenv.local_update(rest_start, rest_ty)
       end
       if msig.post_tys
         msig.post_tys.each_with_index do |ty, i|
           alloc_site2 = alloc_site.add_id(idx += 1)
-          ty = ty.substitute(cur_subst, Config.options[:type_depth_limit]).remove_type_vars
+          ty = ty.substitute(cur_subst, Config.current.options[:type_depth_limit]).remove_type_vars
           nenv, ty = scratch.localize_type(ty, nenv, callee_ep, alloc_site2)
           nenv = nenv.local_update(post_start + i, ty)
         end
@@ -130,7 +132,7 @@ module TypeProf
             next
           end
           alloc_site2 = alloc_site.add_id(key)
-          ty = ty.substitute(cur_subst, Config.options[:type_depth_limit]).remove_type_vars
+          ty = ty.substitute(cur_subst, Config.current.options[:type_depth_limit]).remove_type_vars
           nenv, ty = scratch.localize_type(ty, nenv, callee_ep, alloc_site2)
           nenv = nenv.local_update(kw_start + i, ty)
         end
@@ -138,7 +140,7 @@ module TypeProf
       if msig.kw_rest_ty
         ty = msig.kw_rest_ty
         alloc_site2 = alloc_site.add_id(:**)
-        ty = ty.substitute(cur_subst, Config.options[:type_depth_limit]).remove_type_vars
+        ty = ty.substitute(cur_subst, Config.current.options[:type_depth_limit]).remove_type_vars
         nenv, ty = scratch.localize_type(ty, nenv, callee_ep, alloc_site2)
         nenv = nenv.local_update(kw_rest, ty)
       end
@@ -209,9 +211,10 @@ module TypeProf
       @sig_rets = sig_rets
       @rbs_source = rbs_source
       @pub_meth = pub_meth
+      @iseq = nil
     end
 
-    attr_reader :rbs_source
+    attr_reader :rbs_source, :iseq
 
     def do_send(recv_orig, mid, aargs, caller_ep, caller_env, scratch, &ctn)
       recv = scratch.globalize_type(recv_orig, caller_env, caller_ep)
@@ -254,7 +257,7 @@ module TypeProf
             bsig = msig.blk_ty.block_body.msig
             alloc_site = AllocationSite.new(caller_ep).add_id(self)
             nlead_tys = (bsig.lead_tys + bsig.opt_tys).map.with_index do |ty, i|
-              ty = ty.substitute(subst, Config.options[:type_depth_limit]).remove_type_vars
+              ty = ty.substitute(subst, Config.current.options[:type_depth_limit]).remove_type_vars
               dummy_env, ty = scratch.localize_type(ty, dummy_env, dummy_ep, alloc_site.add_id(i))
               ty
             end
@@ -268,7 +271,7 @@ module TypeProf
                     ncaller_env = recv_orig.update_container_elem_type(subst2, ncaller_env, caller_ep, scratch)
                     scratch.merge_return_env(caller_ep) {|env| env ? env.merge(ncaller_env) : ncaller_env }
                   end
-                  ret_ty2 = ret_ty.substitute(subst2, Config.options[:type_depth_limit]).remove_type_vars
+                  ret_ty2 = ret_ty.substitute(subst2, Config.current.options[:type_depth_limit]).remove_type_vars
                 else
                   ret_ty2 = Type.any
                 end
@@ -283,12 +286,12 @@ module TypeProf
             # XXX: a block is passed to a method that does not accept block.
             # Should we call the passed block with any arguments?
             ret_ty = ret_ty.remove_type_vars
-            ctn[ret_ty, caller_ep, ncaller_env]
+            ctn[ret_ty, caller_ep, ncaller_env] if ret_ty != Type.bot
           end
         else
-          ret_ty = ret_ty.substitute(subst, Config.options[:type_depth_limit])
+          ret_ty = ret_ty.substitute(subst, Config.current.options[:type_depth_limit])
           ret_ty = ret_ty.remove_type_vars
-          ctn[ret_ty, caller_ep, ncaller_env]
+          ctn[ret_ty, caller_ep, ncaller_env] if ret_ty != Type.bot
         end
       end
 
@@ -303,6 +306,7 @@ module TypeProf
       @sig_rets.each do |msig, _ret_ty|
         iseq_mdef.do_check_send(msig, recv, mid, ep, scratch)
       end
+      @iseq ||= iseq_mdef.iseq
     end
   end
 

data/lib/typeprof/type.rb

@@ -168,7 +168,7 @@ module TypeProf
     end
 
     def remove_type_vars
-      substitute(DummySubstitution, Config.options[:type_depth_limit])
+      substitute(DummySubstitution, Config.current.options[:type_depth_limit])
     end
 
     def include_untyped?(_scratch)
@@ -239,7 +239,7 @@ module TypeProf
               non_class_instances << ty
             end
           end
-          if (Config.options[:union_width_limit] >= 2 && class_instances.size >= Config.options[:union_width_limit]) || (degenerated && class_instances.size >= 2)
+          if (Config.current.options[:union_width_limit] >= 2 && class_instances.size >= Config.current.options[:union_width_limit]) || (degenerated && class_instances.size >= 2)
             create(Utils::Set[Instance.new_degenerate(class_instances), *non_class_instances], elems)
           else
             new(tys, elems)
@@ -322,7 +322,7 @@ module TypeProf
             types.delete(Type::Instance.new(Type::Builtin[:true]))
             bool = true
           end
-          types.delete(Type.any) unless Config.options[:show_untyped]
+          types.delete(Type.any) unless Config.current.options[:show_untyped]
           proc_tys, types = types.partition {|ty| ty.is_a?(Proc) }
           types = types.map {|ty| ty.screen_name(scratch) }
           types << scratch.show_proc_signature(proc_tys) unless proc_tys.empty?
@@ -339,9 +339,6 @@ module TypeProf
             types.join (" | ")
           end
         end
-      rescue SystemStackError
-        p self
-        raise
       end
 
       def globalize(env, visited, depth)
@@ -786,7 +783,7 @@ module TypeProf
       when ::Hash
         Type.gen_hash do |h|
           obj.each do |k, v|
-            k_ty = guess_literal_type(k).globalize(nil, {}, Config.options[:type_depth_limit])
+            k_ty = guess_literal_type(k).globalize(nil, {}, Config.current.options[:type_depth_limit])
             v_ty = guess_literal_type(v)
             h[k_ty] = v_ty
           end
@@ -854,33 +851,46 @@ module TypeProf
     include Utils::StructuralEquality
 
     def screen_name(iseq, scratch)
-      fargs = @lead_tys.map {|ty| ty.screen_name(scratch) }
-      farg_names = []
-      farg_names += iseq.locals[0, @lead_tys.size] if iseq
-      if @opt_tys
-        fargs += @opt_tys.map {|ty| "?" + ty.screen_name(scratch) }
-        farg_names += iseq.locals[@lead_tys.size, @opt_tys.size] if iseq
+      fargs_str = "("
+      sig_help = {}
+      add_farg = -> farg, name, help: false, key: sig_help.size do
+        name = "`#{ name }`" if RBS::Parser::KEYWORDS.key?(name.to_s)
+        name = "noname_#{ name }" if name.is_a?(Integer)
+        fargs_str << ", " if fargs_str != "("
+        i = fargs_str.size
+        fargs_str << (Config.current.options[:show_parameter_names] && name ? "#{ farg } #{ name }" : farg)
+        sig_help[key] = (i...fargs_str.size)
       end
+
+      @lead_tys.zip(iseq ? iseq.locals : []) do |ty, name|
+        add_farg.call(ty.screen_name(scratch), name, help: true)
+      end
+
+      @opt_tys&.zip(iseq ? iseq.locals[@lead_tys.size, @opt_tys.size] : []) do |ty, name|
+        add_farg.call("?" + ty.screen_name(scratch), name, help: true)
+      end
+
       if @rest_ty
-        fargs << ("*" + @rest_ty.screen_name(scratch))
         if iseq
           rest_index = iseq.fargs_format[:rest_start]
-          farg_names << (rest_index ? iseq.locals[rest_index] : nil)
+          name = rest_index ? iseq.locals[rest_index] : nil
         end
+        add_farg.call("*" + @rest_ty.screen_name(scratch), name)
       end
-      if @post_tys
-        fargs += @post_tys.map {|ty| ty.screen_name(scratch) }
-        if iseq
-          post_start = iseq.fargs_format[:post_start]
-          farg_names += (post_start ? iseq.locals[post_start, @post_tys.size] : [nil] * @post_tys.size)
-        end
+
+      if iseq
+        post_start = iseq.fargs_format[:post_start]
+        names = post_start ? iseq.locals[post_start, @post_tys.size] : []
       end
-      if @kw_tys
-        @kw_tys.each do |req, sym, ty|
-          opt = req ? "" : "?"
-          fargs << "#{ opt }#{ sym }: #{ ty.screen_name(scratch) }"
-        end
+      @post_tys&.zip(names || []) do |ty, name|
+        add_farg.call(ty.screen_name(scratch), name)
+      end
+
+      @kw_tys&.each do |req, sym, ty|
+        opt = req ? "" : "?"
+        add_farg.call("#{ opt }#{ sym }: #{ ty.screen_name(scratch) }", nil, help: true, key: sym)
       end
+
       if @kw_rest_ty
         all_val_ty = Type.bot
         @kw_rest_ty.each_child_global do |ty|
@@ -892,18 +902,16 @@ module TypeProf
           end
           all_val_ty = all_val_ty.union(val_ty)
         end
-        fargs << ("**" + all_val_ty.screen_name(scratch))
+        add_farg.call("**" + all_val_ty.screen_name(scratch), nil)
       end
-      if Config.options[:show_parameter_names]
-        farg_names = farg_names.map {|name| name == :type ? :type_ : name } # XXX: workaround of RBS parser bug
-        farg_names = farg_names.map {|name| name.is_a?(Integer) ? "noname_#{ name }" : name }
-        fargs = fargs.zip(farg_names).map {|farg, name| name ? "#{ farg } #{ name }" : farg }
-      end
-      fargs = fargs.empty? ? "" : "(#{ fargs.join(", ") })"
+
+      fargs_str << ")"
+
+      fargs_str = "" if fargs_str == "()"
 
       # Dirty Hack: Stop the iteration at most once!
       # I'll remove this hack if RBS removes the limitation of nesting blocks
-      return fargs if caller_locations.any? {|frame| frame.label == "show_block_signature" }
+      return fargs_str, sig_help if caller_locations.any? {|frame| frame.label == "show_block_signature" }
 
       optional = false
       blks = []
@@ -916,12 +924,12 @@ module TypeProf
         end
       end
       if blks != []
-        fargs << " " if fargs != ""
-        fargs << "?" if optional
-        fargs << scratch.show_block_signature(blks)
+        fargs_str << " " if fargs_str != ""
+        fargs_str << "?" if optional
+        fargs_str << scratch.show_block_signature(blks)
       end
 
-      fargs
+      return fargs_str, sig_help
     end
   end
 

data/lib/typeprof/utils.rb

@@ -9,7 +9,7 @@ module TypeProf
       def self.included(klass)
         klass.instance_eval do
           def new(*args)
-            (@table ||= {})[[self] + args] ||= super
+            (Thread.current[:table] ||= {})[[self] + args] ||= super
           end
         end
       end
@@ -191,5 +191,22 @@ module TypeProf
         "#<#{ self.class }:#{ @heap.map {|_key, val| val }.inspect }>"
       end
     end
+
+    class CancelToken
+      def cancelled?
+        return false
+      end
+    end
+
+    class TimerCancelToken < CancelToken
+      def initialize(max_sec)
+        @max_sec = max_sec
+        @start_time = Time.now
+      end
+
+      def cancelled?
+        @max_sec && Time.now - @start_time >= @max_sec
+      end
+    end
   end
 end

data/lib/typeprof/version.rb

@@ -1,3 +1,3 @@
 module TypeProf
-  VERSION = "0.15.0"
+  VERSION = "0.20.0"
 end

data/lib/typeprof.rb

@@ -20,3 +20,6 @@ require_relative "typeprof/import"
 require_relative "typeprof/export"
 require_relative "typeprof/builtin"
 require_relative "typeprof/cli"
+require_relative "typeprof/code-range"
+
+require_relative "typeprof/lsp" if RUBY_VERSION >= "3"

data/smoke/array15.rb

@@ -12,5 +12,5 @@ Foo.new[1] = "str"
 __END__
 # Classes
 class Foo
-  def []=: (*Integer | String args) -> Array[bot]
+  def []=: (*Integer | String args) -> Array[untyped]
 end

data/smoke/array6.rb

@@ -10,8 +10,8 @@ foo(1, "str")
 __END__
 # Classes
 class Object
-  ARY: Array[bot]
+  ARY: Array[untyped]
 
   private
-  def foo: (Integer i, String v) -> Array[bot]
+  def foo: (Integer i, String v) -> Array[untyped]
 end

data/smoke/array8.rb

@@ -9,5 +9,5 @@ end
 __END__
 # Classes
 class Foo
-  def self.foo: (Array[bot] a) -> Array[bot]
+  def self.foo: (Array[untyped] a) -> Array[untyped]
 end

data/smoke/block-args2.rb

@@ -48,11 +48,11 @@ __END__
 class Object
   private
   def f1: { -> nil } -> ^(nil, *bot, nil) -> nil
-  def log1: (nil a, Array[bot] r, nil c) -> nil
+  def log1: (nil a, Array[untyped] r, nil c) -> nil
   def f2: { (:a) -> nil } -> ^(:a, *bot, nil) -> nil
-  def log2: (:a a, Array[bot] r, nil c) -> nil
+  def log2: (:a a, Array[untyped] r, nil c) -> nil
   def f3: { (:a, :b) -> nil } -> ^(:a, *bot, :b) -> nil
-  def log3: (:a a, Array[bot] r, :b c) -> nil
+  def log3: (:a a, Array[untyped] r, :b c) -> nil
   def f4: { (:a, :b, :c) -> nil } -> ^(:a, *:b, :c) -> nil
   def log4: (:a a, [:b] r, :c c) -> nil
   def f5: { (:a, :b, :c, :d) -> nil } -> (^(:a, *:b | :c, :d) -> nil)

data/smoke/block-args3.rb

@@ -57,13 +57,13 @@ __END__
 class Object
   private
   def f1: { -> nil } -> ^(nil, ?:opt, *bot, nil) -> nil
-  def log1: (nil a, :opt o, Array[bot] r, nil c) -> nil
+  def log1: (nil a, :opt o, Array[untyped] r, nil c) -> nil
   def f2: { (:a) -> nil } -> ^(:a, ?:opt, *bot, nil) -> nil
-  def log2: (:a a, :opt o, Array[bot] r, nil c) -> nil
+  def log2: (:a a, :opt o, Array[untyped] r, nil c) -> nil
   def f3: { (:a, :b) -> nil } -> ^(:a, ?:opt, *bot, :b) -> nil
-  def log3: (:a a, :opt o, Array[bot] r, :b c) -> nil
+  def log3: (:a a, :opt o, Array[untyped] r, :b c) -> nil
   def f4: { (:a, :b, :c) -> nil } -> (^(:a, ?:b | :opt, *bot, :c) -> nil)
-  def log4: (:a a, :b | :opt o, Array[bot] r, :c c) -> nil
+  def log4: (:a a, :b | :opt o, Array[untyped] r, :c c) -> nil
   def f5: { (:a, :b, :c, :d) -> nil } -> (^(:a, ?:b | :opt, *:c, :d) -> nil)
   def log5: (:a a, :b | :opt o, [:c] r, :d c) -> nil
   def f6: { (:a, :b, :c, :d, :e) -> nil } -> (^(:a, ?:b | :opt, *:c | :d, :e) -> nil)

data/smoke/break2.rb

@@ -12,5 +12,5 @@ __END__
 # Classes
 class Object
   private
-  def foo: -> (Integer | String)
+  def foo: -> String
 end

data/smoke/gvar2.rb

@@ -8,9 +8,6 @@ __END__
 # Errors
 smoke/gvar2.rb:1: [warning] inconsistent assignment to RBS-declared variable
 
-# Global variables
-#$foo: String
-
 # Classes
 class Object
   private

data/smoke/hash-bot.rb

@@ -8,5 +8,5 @@ __END__
 # Classes
 class Object
   private
-  def foo: -> Hash[Integer, Array[bot]]
+  def foo: -> Hash[Integer, Array[untyped]]
 end

data/smoke/hash4.rb

@@ -7,5 +7,5 @@ __END__
 # Classes
 class Object
   private
-  def foo: -> Hash[bot, bot]
+  def foo: -> Hash[untyped, untyped]
 end

data/smoke/identifier_keywords.rb

@@ -0,0 +1,17 @@
+def type(type)
+end
+
+def out(*out)
+end
+
+def untyped(untyped:)
+end
+
+__END__
+# Classes
+class Object
+  private
+  def type: (untyped `type`) -> nil
+  def out: (*untyped `out`) -> nil
+  def untyped: (untyped: untyped) -> nil
+end

data/smoke/next2.rb

@@ -13,5 +13,5 @@ __END__
 # Classes
 class Object
   private
-  def foo: { -> (Integer | String) } -> (Integer | String)
+  def foo: { -> Integer } -> Integer
 end

data/smoke/or_raise.rb

@@ -0,0 +1,18 @@
+def foo
+  if rand < 0.5
+    1
+  end
+end
+
+def bar
+  x = foo or raise("nil")
+  x.times { }
+end
+
+__END__
+# Classes
+class Object
+  private
+  def foo: -> Integer?
+  def bar: -> Integer
+end

data/smoke/parameterizedd-self.rb

@@ -13,8 +13,8 @@ bar([])
 __END__
 # Classes
 class Object
-  def foo: -> Array[bot]
+  def foo: -> Array[untyped]
 
   private
-  def bar: (Array[bot] ary) -> Array[bot]
+  def bar: (Array[untyped] ary) -> Array[untyped]
 end

data/smoke/pattern-match1.rb

@@ -1,4 +1,5 @@
 # RUBY_VERSION >= 3.0
+# NO_SHOW_ERRORS
 
 def foo
   case [:a, :b, :c]
@@ -11,12 +12,6 @@ end
 foo
 
 __END__
-# Errors
-smoke/pattern-match1.rb:5: [error] undefined method: nil#length
-smoke/pattern-match1.rb:5: [error] undefined method: nil#[]
-smoke/pattern-match1.rb:5: [error] undefined method: nil#[]
-smoke/pattern-match1.rb:5: [error] undefined method: nil#[]
-
 # Classes
 class Object
   private

data/smoke/rbs-vars.rb

@@ -21,9 +21,6 @@ class Foo
 end
 
 __END__
-# Global variables
-#$gvar: :gvar_example
-
 # Classes
 class Object
   private

data/testbed/ao.rb

@@ -291,7 +291,7 @@ end
 
 top
 
-if _dummy = false
+if $0 == __FILE__
   v = Vec.new(0.0, 0.0, 0.0)
   v.vadd(v)
 end

data/typeprof-lsp

@@ -0,0 +1,3 @@
+#!/bin/sh
+
+/home/mame/work/ruby/local/bin/bundle exec exe/typeprof --repo ../gem_rbs_collection/gems -Ilib --lsp

data/typeprof.gemspec

@@ -30,5 +30,5 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_runtime_dependency "rbs", ">= 1.3.1"
+  spec.add_runtime_dependency "rbs", ">= 1.6.2"
 end

data/vscode/.gitignore

@@ -0,0 +1,5 @@
+/out
+node_modules
+.vscode/*
+!.vscode/launch.json
+*.vsix

data/vscode/.vscode/launch.json

@@ -0,0 +1,16 @@
+{
+    "version": "0.1.0",
+    "configurations": [
+        {
+            "name": "Launch Extension",
+            "type": "extensionHost",
+            "request": "launch",
+            "runtimeExecutable": "${execPath}",
+            "args": ["--extensionDevelopmentPath=${workspaceRoot}" ],
+            "stopOnEntry": false,
+            "sourceMaps": true,
+            "outFiles": [ "${workspaceRoot}/out/src/**/*.js" ],
+            "preLaunchTask": "npm: vscode:prepublish"
+        }
+    ]
+}

data/vscode/.vscodeignore

@@ -0,0 +1,7 @@
+/sandbox
+.vscode/**
+/src
+**/*.ts
+**/*.js.map
+**/tsconfig.json
+development.md

data/vscode/README.md

@@ -0,0 +1,22 @@
+# Ruby TypeProf VSCode Integration
+
+*NOTE: This extenstion is very preliminary.*
+
+This is a VSCode extension to help you write Ruby code by using an code analyzer called [Ruby TypeProf](https://github.com/ruby/typeprof/) as a backend.
+
+## How to use this extension
+
+*TBD*
+
+Requirements:
+
+1. Use Ruby 3.1.0 or later, and TypeProf 0.20.0 or later
+2. Add `gem "typeprof"` to your `Gemfile`, and execute `bundle install`
+
+Troubleshooting:
+
+*TBD*
+
+## How to develop this extension
+
+See [development.md](https://github.com/ruby/typeprof/blob/master/development.md).

data/vscode/development.md

@@ -0,0 +1,31 @@
+# LSP client for vscode
+
+Note: this is under development
+
+## How to run
+
+```
+$ cd vscode
+$ npm install
+$ npx run tsc -p ./
+$ cd ..
+$ code --extensionDevelopmentPath=vscode/ .
+```
+
+Alternatively, you can do it in vscode itself.
+
+```
+$ cd vscode
+$ code
+```
+
+And then press F5 to run another vscode with extension.
+
+## How to release
+
+```
+$ npm run package
+$ npx vsce publish
+```
+
+See also: https://code.visualstudio.com/api/working-with-extensions/publishing-extension