typeprof 0.10.0 → 0.14.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8d68099e4f5d60a45f949d6bfc3a47e8b7d3b7ba66a0794f25f5fe61628de1d1
-  data.tar.gz: 22792d1acb9b16a4150f1afbaf29d59987bf29772908b23075e6668df81a4309
+  metadata.gz: d5828bf5dda203756a758bba9809d3b1fe81b284cc1373f00ff75ca175afe998
+  data.tar.gz: c274d8bda556407a33c70227a4caea57f1ae91f79ee546f9076d6ffac01891a5
 SHA512:
-  metadata.gz: 42faa4e3b5c64fd5976e66067bf13339c530785914caad77bc0a405939bc914e9adf78bfbd0aea57a829cb21aed3c6dfc09f8f57def85b09312facd82d33b5a9
-  data.tar.gz: bc6f115fbf1d5292286f04f09d745cfb0c13688a71fdae730d0cfdd903ad8f9f3f9019e532c37b4cf23fe41f39c9a1683f92f28af68716ddf7e625a0efca33f8
+  metadata.gz: e32f209894645a18b36a24c2347e86e249ffa0bcd2c93565d1920551ef143e73f6f3c58011250a545d761e9212aee032e99a44503e4dad5e1975d73de412d3c9
+  data.tar.gz: f3463cbae97beff6b359acb14a3a871f83d0ed37332e46ce38d846b2c486a9af3e6864a5450fe82e0abae79763b71ed55a26f1ab03d6a04aa9eb62232dd435fe

data/.github/workflows/main.yml

@@ -7,7 +7,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        ruby-version: [2.7.1, head]
+        ruby-version: [2.7, 3.0, head]
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v2

data/Gemfile.lock

@@ -1,25 +1,25 @@
 PATH
   remote: .
   specs:
-    typeprof (0.10.0)
-      rbs (>= 0.20.1)
+    typeprof (0.14.1)
+      rbs (>= 1.2.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
     coverage-helpers (1.0.0)
-    docile (1.3.2)
-    power_assert (1.2.0)
+    docile (1.4.0)
+    power_assert (2.0.0)
     rake (13.0.1)
-    rbs (0.20.1)
-    simplecov (0.20.0)
+    rbs (1.2.0)
+    simplecov (0.21.2)
       docile (~> 1.1)
       simplecov-html (~> 0.11)
       simplecov_json_formatter (~> 0.1)
     simplecov-html (0.12.3)
-    simplecov_json_formatter (0.1.2)
-    stackprof (0.2.16)
-    test-unit (3.3.7)
+    simplecov_json_formatter (0.1.3)
+    stackprof (0.2.17)
+    test-unit (3.4.1)
       power_assert
 
 PLATFORMS
@@ -36,4 +36,4 @@ DEPENDENCIES
   typeprof!
 
 BUNDLED WITH
-   2.2.1
+   2.3.0.dev

data/doc/demo.md

@@ -39,7 +39,7 @@ class Object
 end
 ```
 
-Yoy can [try this analysis online](https://mame.github.io/typeprof-playground/#rb=def+hello_message%28user%29%0A++%22The+name+is+%22+%2B+user.name%0Aend%0A%0Adef+type_error_demo%28user%29%0A++%22The+age+is+%22+%2B+user.age%0Aend%0A%0Auser+%3D+User.new%28name%3A+%22John%22%2C+age%3A+20%29%0A%0Ahello_message%28user%29%0Atype_error_demo%28user%29&rbs=class+User%0A++attr_reader+name%3A+String%0A++attr_reader+age%3A+Integer%0A%0A++def+initialize%3A+%28name%3A+String%2C+age%3A+Integer%29+-%3E+void%0Aend).
+You can [try this analysis online](https://mame.github.io/typeprof-playground/#rb=def+hello_message%28user%29%0A++%22The+name+is+%22+%2B+user.name%0Aend%0A%0Adef+type_error_demo%28user%29%0A++%22The+age+is+%22+%2B+user.age%0Aend%0A%0Auser+%3D+User.new%28name%3A+%22John%22%2C+age%3A+20%29%0A%0Ahello_message%28user%29%0Atype_error_demo%28user%29&rbs=class+User%0A++attr_reader+name%3A+String%0A++attr_reader+age%3A+Integer%0A%0A++def+initialize%3A+%28name%3A+String%2C+age%3A+Integer%29+-%3E+void%0Aend).
 
 ## A simple demo to generate the signature prototype of "User" class
 
@@ -190,7 +190,7 @@ p [:a, :b, :c] #=> [:a, :b, :c]
 # A Hash is a "type-to-type" map
 h = { "int" => 1, "float" => 1.0 }
 p h        #=> {String=>Float | Integer}
-p h["int"] #=> Float | Intger
+p h["int"] #=> Float | Integer
 
 # Symbol-key hashes (a.k.a. records) can have distinct types for each key as Symbols are concrete
 h = { int: 1, float: 1.0 }

data/doc/todo.md

@@ -0,0 +1,133 @@
+# TypeProf milestones and TODOs
+
+## Big milestones
+
+### Rails support
+
+There are many known issues for the analysis of typical Ruby programs including Rails apps.
+
+* The main difficulty is that they use many language extensions like `ActiveSupport`.
+  Some features (for example, `blank?` and `Time.now + 1.day`) are trivial to support,
+  but others (for example, `ActiveSupport::Concern` and Zeitwerk) will require special support.
+* The other difficulty is that they heavily use meta-programming features like `ActiveRecord`.
+  It dynamically defines some methods based on external data (such as DB schema) from the code.
+
+Currently, projects called [`gem_rbs`](https://github.com/ruby/gem_rbs) and [`rbs_rails`](https://github.com/pocke/rbs_rails) are in progress.
+The former provides several RBS files for some major gems including Rails.
+The latter is a tool to generate RBS prototype of a target Rails application by introspection (executing it and monitoring DB schema, etc).
+TypeProf can use their results to improve analysis precision and performance.
+
+What we need to do:
+
+* Experimentally apply TypeProf to some Rails programs and identify problems
+* Make TypeProf able to work together with `rbs_rails` for supporting trivial core extensions and `ActiveRecord`.
+* Implement special support for some fundamental language extensions of Rails like `ActiveSupport::Concern`.
+  (It would be best if TypeProf has a plugin system and if we can factor out the special support as a plugin for Rails.)
+
+### Error detection and diagnosis feature
+
+At present, TypeProf focuses on generation of RBS prototype from no-type-annotated Ruby code.
+However, it is possible for TypeProf to report possible errors found during the analysis.
+In fact, an option `-v` experimentally shows possible errors found.
+There are some reasons why it is disabled by default:
+
+* (1) There are too many false positives.
+* (2) Some kind of error reporting is not implemented yet.
+* (3) Some reported errors are difficult for a user to understand.
+
+For (1), we will research how we can avoid false positives to support typical Ruby coding patterns as much as possible.
+The primary way is to improve the analysis precision, e.g., enhancing flow-sensitive analysis.
+If the S/N ratio of an error type is too low, we need to consider to suppress the kind of reports.
+Also, we may try allowing users to guide TypeProf to analyze their program well.
+(The simplest way is to write inline type casts in the code, but we need to find more Ruby/RBS way.)
+We may also explore a "TypeProf-friendly coding style" which TypeProf can analyze well.
+(In principle, the plainer code is, the better TypeProf can analyze.)
+
+For (2), currently, TypeProf checks the argument types of a call to a method whose type signature is declared in RBS.
+However, it does not check the return type yet. Redefinition of constants should be warned too.
+We will survey what errors and warnings TypeProf can print, and evaluate the S/N ratio of each report.
+
+For (3), since TypeProf uses whole program analysis, an error may be reported at a very different place from its root bug.
+Thus, if TypeProf shows a possible type error, a diagnosis feature is needed to answer why TypeProf thinks that the error may occur.
+TypeProf has already implemented a very primitive diagnosis feature, `Kernel#p`, to check what type an expression has.
+Another idea is to create a pseudo backtrace why TypeProf thought the possible type error may occur.
+We should consider this feature with LSP support.
+
+### Performance improvement
+
+Currently, TypeProf is painfully slow. Even if a target application is small.
+
+The main reason is that TypeProf analyzes not only the application code but also library code:
+if an application requires `"foo"`, TypeProf actually loads `foo.rb` even from a gem,
+and furthermore, if `foo.rb` requires `"bar"`, it loads `bar.rb` recursively.
+
+RBS will help to stop this cascade;
+when an application requires `"foo"`, TypeProf loads `sig/foo.rbs` instead of `foo.rb` if the `foo` gem contains both.
+Such a RBS file is optional for TypeProf but required for Steep.
+So, we think many gems will eventually equip their RBS declarations.
+
+That being said, we should continue to improve the analysis performance of TypeProf. We have some ideas.
+
+* Unfortunately, TypeProf often analyzes one method more than once when it accepts multiple types.
+  As TypeProf squashes the argument types to a union, this duplicated analysis is not necessarily needed.
+  But when TypeProf first analyzes a method, it is difficult to determine if the method will accept another type in further analysis.
+  So, we need good heuristics to guess whether a method accepts multiple types or not, and if so, delay its analysis.
+* Currently, TypeProf executes the bytecode instructions step by step.
+  This requires creating an environment object after each instruction, which is very heavy.
+  Many environment creations can be omitted by executing each basic block instead of each instruction.
+  (Basic block execution will also make flow-sensitive analysis easier.)
+* The slowest calculation in TypeProf is to create an instance of a Type class.
+  The creation uses memoization; TypeProf keeps all Type instances created so far, and reuses them if already exist.
+  However, it is very heavy to check if an instance already exists or not.
+  (Currently, it is very simply implemented by a big Hash table.)
+  We've already improved the memoization routine several times but looks like it is still the No.1 bottleneck.
+  We need to investigate and try improving more.
+* TypeProf heavily uses Hash objects (including above) mainly to represent a set.
+  A union of sets is done by `Hash#merge`, which takes O(n).
+  A more lightweight data structure may make TypeProf faster.
+  (But clever structure often has a big constant term, so we need to evaluate the performance carefully.)
+* Reusing an old analysis and incrementally updating it will bring a super big improvement.
+  This would be especially helpful for LSP support, so we need to tackle it after the analysis approach is mature.
+
+### Language Server Protocol (LSP) support
+
+In the future, we want TypeProf to serve as a language server to show the result in IDE in real-time.
+However, the current analysis approach is too slow for IDE. So we need to improve the performance first.
+
+Even if TypeProf becomes fast enough, its approach has a fundamental problem.
+Since TypeProf uses whole program analysis, one edit may cause a cascade of propagation:
+if a user write `foo(42)`, an Integer is propagated to a method `foo`,
+and if `foo` passes its argument to a method `bar`, it is propagated to `bar`, ...
+So, a breakthrough for LSP may be still needed, e.g, limiting the propagation range in real-time analysis,
+assuming that a type interface of module boundary is fixed, etc.
+
+## Relatively smaller TODOs
+
+* Support more RBS features
+  * TypeProf does not deal with some RBS types well yet.
+    * For example, the `instance` type is handled as `untyped.
+    * The `self` type is handled well only when it is used as a return type.
+    * Using a value of the `void` type should be warned appropriately.
+  * RBS's `interface` is supported just like a module (i.e., `include _Foo` is explicitly required in RBS),
+    but it should be checked structually (i.e., it should be determined as a method set.)
+  * The variance of type parameters is currently ignored.
+
+* Support more Ruby features
+  * Some meta-programming features like `Class.new`, `Object#method`, etc.
+    * It is possible to support `Class.new` by per-allocation-site approach:
+      e.g., In TypeProf, `A = Class.new; B = Class.new` will create two classes, but `2.times { Class.new }` will create one class.
+  * The analysis precision can be improved more for some Ruby features like pattern matching, keyword arguments, etc.
+    * For example, `foo(*args, k:1)` is currently compiled as if it is `foo(*(args + [{ :k => 1 }]))` into Ruby bytecode.
+      This mixes the keyword arguments to a rest array, and makes it difficult for TypeProf to track the keyword arguments.
+  * Support Enumerator as an Array-type container.
+  * Support `Module#protect` (but RBS does not yet).
+  * More heuristics may help such as `==` returns a bool regardless to its receiver and argument types.
+
+* Make TypeProf more useful as a tool
+  * Currently, TypeProf provides only the analysis engine and a minimal set of features.
+  * The analysis result would be useful not only to generate RBS prototype
+    but also identifying the source location of a method definition, listing callsites of a method,
+    searching a method call by its argument types, etc.
+  * Sometimes, TypeProf prints very big union type, such as `Integer | Float | Complex | Rational | ...`.
+    Worse, the same big type is printed multiple times.
+    It may be useful to factor out such a long type by using type alias, for example.

data/lib/typeprof/analyzer.rb

@@ -42,6 +42,10 @@ module TypeProf
         "<builtin>"
       end
     end
+
+    def replace_cref(cref)
+      Context.new(@iseq, cref, @mid)
+    end
   end
 
   class TypedContext
@@ -61,6 +65,10 @@ module TypeProf
         "<typed-context:#{ @mid }>"
       end
     end
+
+    def replace_cref(cref)
+      # What to do?
+    end
   end
 
   class ExecutionPoint
@@ -86,6 +94,10 @@ module TypeProf
       ExecutionPoint.new(@ctx, @pc + 1, @outer)
     end
 
+    def replace_cref(cref)
+      ExecutionPoint.new(@ctx.replace_cref(cref), @pc, @outer)
+    end
+
     def source_location
       @ctx.source_location(@pc)
     end
@@ -238,6 +250,8 @@ module TypeProf
     end
 
     def initialize
+      @entrypoints = []
+
       @worklist = Utils::WorkList.new
 
       @ep2env = {}
@@ -272,6 +286,10 @@ module TypeProf
       @anonymous_struct_gen_id = 0
     end
 
+    def add_entrypoint(iseq)
+      @entrypoints << iseq
+    end
+
     attr_reader :return_envs, :loaded_features, :rbs_reader
 
     def get_env(ep)
@@ -878,56 +896,68 @@ module TypeProf
       iter_counter = 0
       stat_eps = Utils::MutableSet.new
 
-      while true
-        until @worklist.empty?
-          ep = @worklist.deletemin
-
-          iter_counter += 1
-          if Config.options[:show_indicator]
-            tick2 = Time.now
-            if tick2 - tick >= 1
-              tick = tick2
-              $stderr << "\rType Profiling... (%d instructions @ %s)\e[K" % [iter_counter, ep.source_location]
-              $stderr.flush
+      prologue_ctx = Context.new(nil, nil, nil)
+      prologue_ep = ExecutionPoint.new(prologue_ctx, -1, nil)
+      prologue_env = Env.new(StaticEnv.new(Type.bot, Type.nil, false, true), [], [], Utils::HashWrapper.new({}))
+
+      until @entrypoints.empty?
+        iseq = @entrypoints.shift
+        ep, env = TypeProf.starting_state(iseq)
+        merge_env(ep, env)
+        add_callsite!(ep.ctx, prologue_ep, prologue_env) {|ty, ep| }
+
+        while true
+          until @worklist.empty?
+            ep = @worklist.deletemin
+
+            iter_counter += 1
+            if Config.options[:show_indicator]
+              tick2 = Time.now
+              if tick2 - tick >= 1
+                tick = tick2
+                $stderr << "\rType Profiling... (%d instructions @ %s)\e[K" % [iter_counter, ep.source_location]
+                $stderr.flush
+              end
             end
-          end
 
-          if (Config.max_sec && Time.now - start_time >= Config.max_sec) || (Config.max_iter && Config.max_iter <= iter_counter)
-            @terminated = true
-            break
-          end
+            if (Config.max_sec && Time.now - start_time >= Config.max_sec) || (Config.max_iter && Config.max_iter <= iter_counter)
+              @terminated = true
+              break
+            end
 
-          stat_eps << ep
-          step(ep)
-        end
+            stat_eps << ep
+            step(ep)
+          end
 
-        break if @terminated
+          break if @terminated
 
-        break unless Config.options[:stub_execution]
+          break unless Config.options[:stub_execution]
 
-        begin
-          iseq, (kind, dummy_continuation) = @pending_execution.first
-          break if !iseq
-          @pending_execution.delete(iseq)
-        end while @executed_iseqs.include?(iseq)
+          begin
+            iseq, (kind, dummy_continuation) = @pending_execution.first
+            break if !iseq
+            @pending_execution.delete(iseq)
+          end while @executed_iseqs.include?(iseq)
 
-        puts "DEBUG: trigger stub execution (#{ iseq&.name || "(nil)" }): rest #{ @pending_execution.size }" if Config.verbose >= 2
+          puts "DEBUG: trigger stub execution (#{ iseq&.name || "(nil)" }): rest #{ @pending_execution.size }" if Config.verbose >= 2
 
-        break if !iseq
-        case kind
-        when :method
-          meth, ep, env = dummy_continuation
-          merge_env(ep, env)
-          add_iseq_method_call!(meth, ep.ctx)
-
-        when :block
-          blk, epenvs = dummy_continuation
-          epenvs.each do |ep, env|
+          break if !iseq
+          case kind
+          when :method
+            meth, ep, env = dummy_continuation
             merge_env(ep, env)
-            add_block_to_ctx!(blk.block_body, ep.ctx)
+            add_iseq_method_call!(meth, ep.ctx)
+
+          when :block
+            blk, epenvs = dummy_continuation
+            epenvs.each do |ep, env|
+              merge_env(ep, env)
+              add_block_to_ctx!(blk.block_body, ep.ctx)
+            end
           end
         end
       end
+
       $stderr.print "\r\e[K" if Config.options[:show_indicator]
 
       stat_eps
@@ -1245,7 +1275,13 @@ module TypeProf
             end
             if cbase.is_a?(Type::Class)
               klass = new_class(cbase, id, [], superclass, ep.ctx.iseq.absolute_path)
-              add_superclass_type_args!(klass, superclass.type_params.map { Type.any }) if superclass
+              if superclass
+                add_superclass_type_args!(klass, superclass.type_params.map { Type.any })
+
+                # inherited hook
+                aargs = ActualArguments.new([klass], nil, {}, Type.nil)
+                do_send(superclass, :inherited, aargs, ep, env) {|_ret_ty, _ep| }
+              end
             else
               klass = Type.any
             end
@@ -1288,7 +1324,7 @@ module TypeProf
           end
         end
         return
-      when :getlocal_send_branch
+      when :recv_getlocal_send_branch
         getlocal_operands, send_operands, branch_operands = operands
         env, recvs, mid, aargs = setup_actual_arguments(:method, send_operands, ep, env)
         recvs = Type.any if recvs == Type.bot
@@ -1316,6 +1352,39 @@ module TypeProf
           end
         end
         return
+      when :arg_getlocal_send_branch
+        getlocal_operands, send_operands, branch_operands = operands
+        env, recvs, mid, aargs = setup_actual_arguments(:method, send_operands, ep, env)
+        raise if aargs.lead_tys.size != 1
+        aarg = aargs.lead_tys[0]
+        aarg = Type.any if aarg == Type.bot
+        recvs.each_child do |recv|
+          aarg.each_child do |aarg|
+            aargs_tmp = ActualArguments.new([aarg], nil, {}, aargs.blk_ty)
+            do_send(recv, mid, aargs_tmp, ep, env) do |ret_ty, ep, env|
+              env, ret_ty, = localize_type(ret_ty, env, ep)
+
+              branchtype, target, = branch_operands
+              # branchtype: :if or :unless or :nil
+              ep_then = ep.next
+              ep_else = ep.jump(target)
+
+              var_idx, _scope_idx, _escaped = getlocal_operands
+              flow_env = env.local_update(-var_idx+2, aarg)
+
+              case ret_ty
+              when Type::Instance.new(Type::Builtin[:true])
+                merge_env(branchtype == :if ? ep_else : ep_then, flow_env)
+              when Type::Instance.new(Type::Builtin[:false])
+                merge_env(branchtype == :if ? ep_then : ep_else, flow_env)
+              else
+                merge_env(ep_then, env)
+                merge_env(ep_else, env)
+              end
+            end
+          end
+        end
+        return
       when :send_branch
         send_operands, branch_operands = operands
         env, recvs, mid, aargs = setup_actual_arguments(:method, send_operands, ep, env)
@@ -1419,7 +1488,7 @@ module TypeProf
             end
             _type, _iseq, cont, stack_depth = tmp_ep.ctx.iseq.catch_table[tmp_ep.pc]&.find {|type,| type == :break }
             if cont
-              nenv = @return_envs[tmp_ep]
+              nenv = @return_envs[tmp_ep] || env
               nenv, = nenv.pop(nenv.stack.size - stack_depth)
               nenv = nenv.push(ty)
               tmp_ep = tmp_ep.jump(cont)
@@ -1778,8 +1847,10 @@ module TypeProf
       when :nop
       when :setn
         idx, = operands
-        env, (ty,) = env.pop(1)
-        env = env.setn(idx, ty).push(ty)
+        if idx >= 1
+          env, (ty,) = env.pop(1)
+          env = env.setn(idx, ty).push(ty)
+        end
       when :topn
         idx, = operands
         env = env.topn(idx)
@@ -2091,10 +2162,10 @@ module TypeProf
       end
     end
 
-    def do_invoke_block(blk, aargs, ep, env, replace_recv_ty: nil, &ctn)
+    def do_invoke_block(blk, aargs, ep, env, replace_recv_ty: nil, replace_cref: nil, &ctn)
       blk.each_child do |blk|
         if blk.is_a?(Type::Proc)
-          blk.block_body.do_call(aargs, ep, env, self, replace_recv_ty: replace_recv_ty, &ctn)
+          blk.block_body.do_call(aargs, ep, env, self, replace_recv_ty: replace_recv_ty, replace_cref: replace_cref, &ctn)
         else
           warn(ep, "non-proc is passed as a block")
           ctn[Type.any, ep, env]
@@ -2192,10 +2263,13 @@ module TypeProf
       farg_tys = @method_signatures[ctx]
       ret_ty = @return_values[ctx] || Type.bot
 
+      untyped = farg_tys.include_untyped?(self) || ret_ty.include_untyped?(self)
+
       farg_tys = farg_tys.screen_name(ctx.iseq, self)
       ret_ty = ret_ty.screen_name(self)
       ret_ty = (ret_ty.include?("|") ? "(#{ ret_ty })" : ret_ty) # XXX?
-      "#{ (farg_tys.empty? ? "" : "#{ farg_tys } ") }-> #{ ret_ty }"
+
+      ["#{ (farg_tys.empty? ? "" : "#{ farg_tys } ") }-> #{ ret_ty }", untyped]
     end
   end
 end