typeprof 0.21.11 → 0.30.0

data/lib/typeprof/core/ast/method.rb

@@ -0,0 +1,335 @@
+module TypeProf::Core
+  class AST
+    def self.get_rbs_comment_before(raw_node, lenv)
+      comments = Fiber[:comments]
+      i = comments.bsearch_index {|comment| comment.location.start_line >= raw_node.location.start_line } || comments.size
+      lineno = raw_node.location.start_line
+      rbs_comments = []
+      while i > 0
+        i -= 1
+        lineno -= 1
+        comment = comments[i]
+        comment_loc = comment.location
+        comment_text = comment_loc.slice
+        if comment_loc.start_line == lineno && comment_text.start_with?("#:")
+          rbs_comments[comment_loc.start_line] = " " * (comment_loc.start_column + 2) + comment_text[2..]
+        else
+          break
+        end
+      end
+      return nil if rbs_comments.empty?
+      rbs_comments = rbs_comments.map {|line| line || "" }.join("\n")
+      method_type = RBS::Parser.parse_method_type(rbs_comments)
+      if method_type
+        AST.create_rbs_func_type(method_type, method_type.type_params, method_type.block, lenv)
+      else
+        nil
+      end
+    rescue RBS::ParsingError
+      # TODO: report the error
+      nil
+    end
+
+    def self.parse_params(tbl, raw_args, lenv)
+      unless raw_args
+        return {
+          req_positionals: [],
+          opt_positionals: [],
+          opt_positional_defaults: [],
+          rest_positionals: nil,
+          post_positionals: [],
+          req_keywords: [],
+          opt_keywords: [],
+          opt_keyword_defaults: [],
+          rest_keywords: nil,
+          block: nil,
+        }
+      end
+
+      args_code_ranges = []
+      req_positionals = []
+      raw_args.requireds.each do |n|
+        args_code_ranges << TypeProf::CodeRange.from_node(n.location)
+        req_positionals << (n.is_a?(Prism::MultiTargetNode) ? nil : n.name)
+      end
+
+      # pre_init = args[1]
+
+      opt_positionals = []
+      opt_positional_defaults = []
+      raw_args.optionals.each do |n|
+        opt_positionals << n.name
+        opt_positional_defaults << AST.create_node(n.value, lenv)
+      end
+
+      post_positionals = raw_args.posts.map {|n| (n.is_a?(Prism::MultiTargetNode) ? nil : n.name) }
+
+      rest_positionals = raw_args.rest&.name
+
+      req_keywords = []
+      opt_keywords = []
+      opt_keyword_defaults = []
+
+      raw_args.keywords.each do |kw|
+        case kw.type
+        when :required_keyword_parameter_node
+          req_keywords << kw.name
+        when :optional_keyword_parameter_node
+          opt_keywords << kw.name
+          opt_keyword_defaults << AST.create_node(kw.value, lenv)
+        end
+      end
+
+      case raw_args.keyword_rest
+      when Prism::KeywordRestParameterNode
+        rest_keywords = raw_args.keyword_rest.name if raw_args.keyword_rest
+      when Prism::NoKeywordsParameterNode
+        # what to do?
+      when nil
+        # nothing to do
+      else
+        raise "unexpected keyword rest: #{ raw_args.keyword_rest.class }"
+      end
+
+      block = raw_args.block.name if raw_args.block
+
+      {
+        req_positionals:,
+        opt_positionals:,
+        opt_positional_defaults:,
+        rest_positionals:,
+        post_positionals:,
+        req_keywords:,
+        opt_keywords:,
+        opt_keyword_defaults:,
+        rest_keywords:,
+        block:,
+        args_code_ranges:
+      }
+    end
+
+    class DefNode < Node
+      def initialize(raw_node, lenv, use_result)
+        super(raw_node, lenv)
+        # TODO: warn "def self.foo" in a metaclass
+        singleton = !!raw_node.receiver || lenv.cref.scope_level == :metaclass
+        mid = raw_node.name
+        mid_code_range = TypeProf::CodeRange.from_node(raw_node.name_loc)
+        @tbl = raw_node.locals
+        raw_args = raw_node.parameters
+        raw_body = raw_node.body
+
+        @rbs_method_type = AST.get_rbs_comment_before(raw_node, lenv)
+
+        @singleton = singleton
+        @mid = mid
+        @mid_code_range = mid_code_range
+
+        ncref = CRef.new(lenv.cref.cpath, @singleton ? :class : :instance, @mid, lenv.cref)
+        nlenv = LocalEnv.new(@lenv.path, ncref, {}, [])
+        if raw_body
+          @body = AST.create_node(raw_body, nlenv)
+        else
+          pos = code_range.last.left.left.left # before "end"
+          cr = TypeProf::CodeRange.new(pos, pos)
+          @body = DummyNilNode.new(cr, nlenv)
+        end
+
+        h = AST.parse_params(@tbl, raw_args, nlenv)
+        @req_positionals = h[:req_positionals]
+        @opt_positionals = h[:opt_positionals]
+        @opt_positional_defaults = h[:opt_positional_defaults]
+        @rest_positionals = h[:rest_positionals]
+        @post_positionals = h[:post_positionals]
+        @req_keywords = h[:req_keywords]
+        @opt_keywords = h[:opt_keywords]
+        @opt_keyword_defaults = h[:opt_keyword_defaults]
+        @rest_keywords = h[:rest_keywords]
+        @block = h[:block]
+        @args_code_ranges = h[:args_code_ranges] || []
+
+        # If the result of `def` statement, stop reusing this node
+        # TODO: `private def ...` should be handled well
+        @reusable = !use_result
+      end
+
+      attr_reader :singleton, :mid, :mid_code_range
+      attr_reader :tbl
+      attr_reader :req_positionals
+      attr_reader :opt_positionals
+      attr_reader :opt_positional_defaults
+      attr_reader :rest_positionals
+      attr_reader :post_positionals
+      attr_reader :req_keywords
+      attr_reader :opt_keywords
+      attr_reader :opt_keyword_defaults
+      attr_reader :rest_keywords
+      attr_reader :block
+      attr_reader :body
+      attr_reader :rbs_method_type
+      attr_reader :reusable
+
+      def subnodes = {
+        body:,
+        opt_positional_defaults:,
+        opt_keyword_defaults:,
+        rbs_method_type:,
+      }
+      def attrs = {
+        singleton:,
+        mid:,
+        mid_code_range:,
+        tbl:,
+        req_positionals:,
+        opt_positionals:,
+        rest_positionals:,
+        post_positionals:,
+        req_keywords:,
+        opt_keywords:,
+        rest_keywords:,
+        block:,
+        reusable:,
+      }
+
+      def mname_code_range(_name) = @mid_code_range
+
+      def define(genv) # NOT define0
+        return define_copy(genv) if @prev_node && @reusable
+        super(genv)
+      end
+
+      def install(genv) # NOT install0
+        return install_copy(genv) if @prev_node && @reusable
+        super(genv)
+      end
+
+      def install0(genv)
+        if @rbs_method_type
+          @changes.add_method_decl_box(genv, @lenv.cref.cpath, @singleton, @mid, [@rbs_method_type], false)
+        end
+
+        @tbl.each {|var| @body.lenv.locals[var] = Source.new(genv.nil_type) }
+        @body.lenv.locals[:"*self"] = @body.lenv.cref.get_self(genv)
+
+        req_positionals = @req_positionals.map {|var| @body.lenv.new_var(var, self) }
+        opt_positionals = @opt_positionals.map {|var| @body.lenv.new_var(var, self) }
+        rest_positionals = @rest_positionals ? @body.lenv.new_var(@rest_positionals, self) : nil
+        post_positionals = @post_positionals.map {|var| @body.lenv.new_var(var, self) }
+        req_keywords = @req_keywords.map {|var| @body.lenv.new_var(var, self) }
+        opt_keywords = @opt_keywords.map {|var| @body.lenv.new_var(var, self) }
+        rest_keywords = @rest_keywords ? @body.lenv.new_var(@rest_keywords, self) : nil
+        block = @block ? @body.lenv.new_var(@block, self) : nil
+
+        @opt_positional_defaults.zip(opt_positionals) do |expr, vtx|
+          @changes.add_edge(genv, expr.install(genv), vtx)
+        end
+        @opt_keyword_defaults.zip(opt_keywords) do |expr, vtx|
+          @changes.add_edge(genv, expr.install(genv), vtx)
+        end
+
+        if block
+          block = @body.lenv.set_var(:"*given_block", block)
+        else
+          block = @body.lenv.new_var(:"*given_block", self)
+        end
+
+        if @body
+          e_ret = @body.lenv.locals[:"*expected_method_ret"] = Vertex.new(self)
+          @body.install(genv)
+          @body.lenv.add_return_box(@changes.add_escape_box(genv, @body.ret, e_ret))
+        end
+
+        f_args = FormalArguments.new(
+          req_positionals,
+          opt_positionals,
+          rest_positionals,
+          post_positionals,
+          req_keywords,
+          opt_keywords,
+          rest_keywords,
+          block,
+        )
+
+        @changes.add_method_def_box(genv, @lenv.cref.cpath, @singleton, @mid, f_args, @body.lenv.return_boxes)
+
+        Source.new(Type::Symbol.new(genv, @mid))
+      end
+
+      def last_stmt_code_range
+        if @body
+          if @body.is_a?(AST::StatementsNode)
+            @body.stmts.last.code_range
+          else
+            @body.code_range
+          end
+        else
+          nil
+        end
+      end
+
+      def retrieve_at(pos, &blk)
+        if @rbs_method_type
+          if @rbs_method_type.code_range.include?(pos) # annotation
+            @rbs_method_type.retrieve_at(pos, &blk)
+          end
+        end
+        @args_code_ranges.each_with_index do |cr, i|
+          if cr.include?(pos)
+            yield DummySymbolNode.new(@tbl[i], cr, @body.lenv.get_var(@tbl[i]))
+            break
+          end
+        end
+        super(pos, &blk)
+      end
+
+      def modified_vars(tbl, vars)
+        # skip
+      end
+    end
+
+    class AliasNode < Node
+      def initialize(raw_node, lenv)
+        super(raw_node, lenv)
+        @new_mid = AST.create_node(raw_node.new_name, lenv)
+        @old_mid = AST.create_node(raw_node.old_name, lenv)
+      end
+
+      attr_reader :new_mid, :old_mid
+
+      def subnodes = { new_mid:, old_mid: }
+
+      def install0(genv)
+        @new_mid.install(genv)
+        @old_mid.install(genv)
+        if @new_mid.is_a?(SymbolNode) && @old_mid.is_a?(SymbolNode)
+          new_mid = @new_mid.lit
+          old_mid = @old_mid.lit
+          box = @changes.add_method_alias_box(genv, @lenv.cref.cpath, false, new_mid, old_mid)
+          box.ret
+        else
+          Source.new(genv.nil_type)
+        end
+      end
+    end
+
+    class UndefNode < Node
+      def initialize(raw_node, lenv)
+        super(raw_node, lenv)
+        @names = raw_node.names.map do |raw_name|
+          AST.create_node(raw_name, lenv)
+        end
+      end
+
+      attr_reader :names
+
+      def subnodes = { names: }
+
+      def install0(genv)
+        @names.each do |name|
+          name.install(genv)
+        end
+        Source.new(genv.nil_type)
+      end
+    end
+  end
+end

data/lib/typeprof/core/ast/misc.rb

@@ -0,0 +1,263 @@
+module TypeProf::Core
+  class AST
+    class StatementsNode < Node
+      def initialize(raw_node, lenv, use_result)
+        super(raw_node, lenv)
+        stmts = raw_node.body
+        @stmts = stmts.map.with_index do |n, i|
+          if n
+            AST.create_node(n, lenv, i == stmts.length - 1 ? use_result : false)
+          else
+            last = code_range.last
+            DummyNilNode.new(TypeProf::CodeRange.new(last, last), lenv)
+          end
+        end
+      end
+
+      attr_reader :stmts
+
+      def subnodes = { stmts: }
+
+      def install0(genv)
+        ret = nil
+        @stmts.each do |stmt|
+          ret = stmt ? stmt.install(genv) : nil
+        end
+        if ret
+          ret2 = Vertex.new(self)
+          @changes.add_edge(genv, ret, ret2)
+          ret2
+        else
+          Source.new(genv.nil_type)
+        end
+      end
+
+      def diff(prev_node)
+        if prev_node.is_a?(StatementsNode)
+          i = 0
+          while i < @stmts.size
+            @stmts[i].diff(prev_node.stmts[i])
+            if !@stmts[i].prev_node
+              j1 = @stmts.size - 1
+              j2 = prev_node.stmts.size - 1
+              while j1 >= i && j2 >= i
+                @stmts[j1].diff(prev_node.stmts[j2])
+                if !@stmts[j1].prev_node
+                  return
+                end
+                j1 -= 1
+                j2 -= 1
+              end
+              return
+            end
+            i += 1
+          end
+          @prev_node = prev_node if i == prev_node.stmts.size
+        end
+      end
+    end
+
+    class MultiWriteNode < Node
+      def initialize(raw_node, lenv)
+        super(raw_node, lenv)
+        @value = AST.create_node(raw_node.value, lenv)
+        @lefts = raw_node.lefts.map do |raw_lhs|
+          AST.create_target_node(raw_lhs, lenv)
+        end
+        if raw_node.rest
+          # TODO: need more complex case handling
+          @rest_exist = true
+          case raw_node.rest.type
+          when :splat_node
+            if raw_node.rest.expression
+              @rest = AST.create_target_node(raw_node.rest.expression, lenv)
+            end
+          when :implicit_rest_node
+          else
+            raise "unexpected rest node: #{raw_node.rest.type}"
+          end
+        end
+        @rights = raw_node.rights.map do |raw_lhs|
+          AST.create_target_node(raw_lhs, lenv)
+        end
+        # TODO: raw_node.rest, raw_node.rights
+      end
+
+      attr_reader :value, :lefts, :rest, :rest_exist, :rights
+
+      def subnodes = { value:, lefts:, rest:, rights: }
+      def attrs = { rest_exist: }
+
+      def install0(genv)
+        value = @value.install(genv)
+
+        @lefts.each {|lhs| lhs.install(genv) }
+        @lefts.each {|lhs| lhs.rhs.ret || raise(lhs.rhs.inspect) }
+        lefts = @lefts.map {|lhs| lhs.rhs.ret }
+
+        if @rest_exist
+          rest_elem = Vertex.new(self)
+          if @rest
+            @rest.install(genv)
+            @rest.rhs.ret || raise(@rest.rhs.inspect)
+            @changes.add_edge(genv, Source.new(Type::Instance.new(genv, genv.mod_ary, [rest_elem])), @rest.rhs.ret)
+          end
+        end
+
+        if @rights
+          @rights.each {|lhs| lhs.install(genv) }
+          @rights.each {|lhs| lhs.rhs.ret || raise(lhs.rhs.inspect) }
+          rights = @rights.map {|rhs| rhs.ret }
+        end
+
+        box = @changes.add_masgn_box(genv, value, lefts, rest_elem, rights)
+        box.ret
+      end
+
+      def retrieve_at(pos, &blk)
+        yield self if @var_code_range && @var_code_range.include?(pos)
+        super(pos, &blk)
+      end
+    end
+
+    class MatchWriteNode < Node
+      def initialize(raw_node, lenv)
+        super(raw_node, lenv)
+        @call = AST.create_node(raw_node.call, lenv)
+        @targets = raw_node.targets.map do |raw_lhs|
+          AST.create_target_node(raw_lhs, lenv)
+        end
+      end
+
+      attr_reader :call, :targets
+      def subnodes = { call:, targets: }
+
+      def install0(genv)
+        ret = @call.install(genv)
+        @targets.each do |target|
+          target.install(genv)
+          target.rhs.ret || raise(target.rhs.inspect)
+          @changes.add_edge(genv, Source.new(Type::Instance.new(genv, genv.mod_str, [])), target.rhs.ret)
+        end
+        ret
+      end
+    end
+
+    class DefinedNode < Node
+      def initialize(raw_node, lenv)
+        super(raw_node, lenv)
+        @arg = AST.create_node(raw_node.value, lenv)
+      end
+
+      attr_reader :arg
+
+      def subnodes = {} # no arg!
+
+      def install0(genv)
+        Source.new(genv.true_type, genv.false_type)
+      end
+    end
+
+    class SourceEncodingNode < Node
+      def install0(genv)
+        Source.new(Type::Instance.new(genv, genv.resolve_cpath([:Encoding]), []))
+      end
+    end
+
+    class SplatNode < Node
+      def initialize(raw_node, lenv)
+        super(raw_node, lenv)
+        @expr = AST.create_node(raw_node.expression, lenv)
+      end
+
+      attr_reader :expr
+
+      def subnodes = { expr: }
+
+      def mid_code_range = nil
+
+      def install0(genv)
+        vtx = @expr.install(genv)
+
+        a_args = ActualArguments.new([], [], nil, nil)
+        vtx = @changes.add_method_call_box(genv, vtx, :to_a, a_args, false).ret
+
+        @changes.add_splat_box(genv, vtx).ret
+      end
+    end
+
+    class ForNode < Node
+      def initialize(raw_node, lenv)
+        super(raw_node, lenv)
+        # XXX: tentative implementation
+        # raw_node.index
+        @expr = AST.create_node(raw_node.collection, lenv)
+        @body = raw_node.statements ? AST.create_node(raw_node.statements, lenv) : DummyNilNode.new(TypeProf::CodeRange.new(code_range.last, code_range.last), lenv)
+      end
+
+      attr_reader :expr, :body
+
+      def subnodes = { expr:, body: }
+
+      def install0(genv)
+        @expr.install(genv)
+        @body.install(genv)
+        Source.new(genv.nil_type)
+      end
+    end
+
+    class FlipFlopNode < Node
+      def initialize(raw_node, lenv)
+        super(raw_node, lenv)
+        @e1 = AST.create_node(raw_node.left, lenv)
+        @e2 = AST.create_node(raw_node.right, lenv)
+      end
+
+      attr_reader :e1, :e2
+
+      def subnodes = { e1:, e2: }
+
+      def install0(genv)
+        @e1.install(genv)
+        @e2.install(genv)
+        Source.new(genv.true_type, genv.false_type)
+      end
+    end
+
+    class MatchRequiredNode < Node
+      def initialize(raw_node, lenv)
+        super(raw_node, lenv)
+        @value = AST.create_node(raw_node.value, lenv)
+        @pat = AST.create_pattern_node(raw_node.pattern, lenv)
+      end
+
+      attr_reader :value, :pat
+
+      def subnodes = { value:, pat: }
+
+      def install0(genv)
+        @value.install(genv)
+        @pat.install(genv)
+        Source.new(genv.nil_type)
+      end
+    end
+
+    class MatchPreidcateNode < Node
+      def initialize(raw_node, lenv)
+        super(raw_node, lenv)
+        @value = AST.create_node(raw_node.value, lenv)
+        @pat = AST.create_pattern_node(raw_node.pattern, lenv)
+      end
+
+      attr_reader :value, :pat
+
+      def subnodes = { value:, pat: }
+
+      def install0(genv)
+        @value.install(genv)
+        @pat.install(genv)
+        Source.new(genv.true_type, genv.false_type)
+      end
+    end
+  end
+end

data/lib/typeprof/core/ast/module.rb

@@ -0,0 +1,123 @@
+module TypeProf::Core
+  class AST
+    class ModuleBaseNode < Node
+      def initialize(raw_node, lenv, raw_cpath, meta, raw_scope, use_result)
+        super(raw_node, lenv)
+
+        @cpath = AST.create_node(raw_cpath, lenv)
+        @static_cpath = AST.parse_cpath(raw_cpath, lenv.cref)
+        @tbl = raw_node.locals
+
+        # TODO: class Foo < Struct.new(:foo, :bar)
+
+        if @static_cpath
+          ncref = CRef.new(@static_cpath, meta ? :metaclass : :class, nil, lenv.cref)
+          nlenv = LocalEnv.new(@lenv.path, ncref, {}, [])
+          @body = raw_scope ? AST.create_node(raw_scope, nlenv, use_result) : DummyNilNode.new(code_range, lenv)
+        else
+          @body = nil
+        end
+
+        @cname_code_range = meta ? nil : TypeProf::CodeRange.from_node(raw_node.constant_path)
+      end
+
+      attr_reader :tbl, :cpath, :static_cpath, :cname_code_range, :body
+
+      def subnodes = { cpath:, body: }
+      def attrs = { static_cpath:, tbl: }
+
+      def define0(genv)
+        @cpath.define(genv)
+        if @static_cpath
+          @body.define(genv)
+          @mod = genv.resolve_cpath(@static_cpath)
+          @mod_cdef = @mod.add_module_def(genv, self)
+        else
+          kind = self.is_a?(ModuleNode) ? "module" : "class"
+          @changes.add_diagnostic(:code_range, "TypeProf cannot analyze a non-static #{ kind }") # warning
+          nil
+        end
+      end
+
+      def define_copy(genv)
+        if @static_cpath
+          @mod_cdef.add_def(self)
+          @mod_cdef.remove_def(@prev_node)
+        end
+        super(genv)
+      end
+
+      def undefine0(genv)
+        if @static_cpath
+          @mod.remove_module_def(genv, self)
+          @body.undefine(genv)
+        end
+        @cpath.undefine(genv)
+      end
+
+      def install0(genv)
+        @cpath.install(genv)
+        if @static_cpath
+          @tbl.each {|var| @body.lenv.locals[var] = Source.new(genv.nil_type) }
+          @body.lenv.locals[:"*self"] = @body.lenv.cref.get_self(genv)
+
+          @mod_val = Source.new(Type::Singleton.new(genv, genv.resolve_cpath(@static_cpath)))
+          @changes.add_edge(genv, @mod_val, @mod_cdef.vtx)
+          ret = Vertex.new(self)
+          @changes.add_edge(genv, @body.install(genv), ret)
+          ret
+        else
+          Source.new
+        end
+      end
+
+      def modified_vars(tbl, vars)
+        # skip
+      end
+    end
+
+    class ModuleNode < ModuleBaseNode
+      def initialize(raw_node, lenv, use_result)
+        super(raw_node, lenv, raw_node.constant_path, false, raw_node.body, use_result)
+      end
+    end
+
+    class ClassNode < ModuleBaseNode
+      def initialize(raw_node, lenv, use_result)
+        super(raw_node, lenv, raw_node.constant_path, false, raw_node.body, use_result)
+        raw_superclass = raw_node.superclass
+        @superclass_cpath = raw_superclass ? AST.create_node(raw_superclass, lenv) : nil
+      end
+
+      attr_reader :superclass_cpath
+
+      def subnodes
+        super.merge!({ superclass_cpath: })
+      end
+
+      def define0(genv)
+        if @static_cpath && @superclass_cpath
+          const = @superclass_cpath.define(genv)
+          const.followers << genv.resolve_cpath(@static_cpath) if const
+        end
+        super(genv)
+      end
+
+      def undefine0(genv)
+        super(genv)
+        @superclass_cpath.undefine(genv) if @superclass_cpath
+      end
+
+      def install0(genv)
+        @superclass_cpath.install(genv) if @superclass_cpath
+        super(genv)
+      end
+    end
+
+    class SingletonClassNode < ModuleBaseNode
+      def initialize(raw_node, lenv, use_result)
+        super(raw_node, lenv, raw_node.expression, true, raw_node.body, use_result)
+      end
+    end
+  end
+end