rbs-trace 0.3.2 → 0.4.1

data/lib/rbs/trace/file.rb

@@ -1,29 +1,43 @@
 # frozen_string_literal: true
 
+require "stringio"
+
 module RBS
-  module Trace
+  class Trace
     class File
-      # @rbs (String) -> void
-      def initialize(path)
+      include Helpers
+
+      # @rbs (String, ?Hash[TypeName, AST::Declarations::t]) -> void
+      def initialize(path, decls = {})
         @path = path
+        @decls = decls
+        @members = {} #: Hash[TypeName, AST::Declarations::t]
       end
 
-      # @rbs () -> Hash[String, Definition]
-      def definitions
-        @definitions ||= {}
+      # @rbs (untyped, Class, Symbol) -> AST::Members::MethodDefinition?
+      def find_or_new_method_definition(object, defined_class, name)
+        klass = defined_class.singleton_class? ? object : defined_class
+        receiver_decl = find_or_new_receiver_decl(klass)
+        return unless receiver_decl
+
+        kind = defined_class.singleton_class? ? :singleton : :instance
+        key = [receiver_decl.name, name, kind]
+        @members[key] ||= new_method_definition(name:, kind:).tap do |member| # steep:ignore ArgumentTypeMismatch
+          receiver_decl.members << member
+        end
       end
 
       # @rbs () -> String
       def with_rbs
-        lines = ::File.readlines(@path)
-        reverse_definitions.each do |d|
-          next if skip_insert?(lines, d)
+        result = Prism.parse_file(@path)
+        comments = {} #: Hash[Integer, String]
+        result.value.accept(InlineCommentVisitor.new(@decls, comments))
 
-          current = d.lineno - 1
-          indent = lines[current]&.index("def")
-          next unless indent
+        lines = result.source.source.lines
+        comments.keys.sort.reverse_each do |i|
+          next if skip_insert?(lines, i)
 
-          lines.insert(current, d.rbs_comment(indent))
+          lines.insert(i, comments[i])
         end
         lines.join
       end
@@ -33,22 +47,53 @@ module RBS
         ::File.write(@path, with_rbs)
       end
 
+      # @rbs () -> String
+      def to_rbs
+        out = StringIO.new
+        writer = Writer.new(out:)
+        writer.write(@decls.values)
+
+        out.string
+      end
+
+      # @rbs (String) -> void
+      def save_rbs(out_dir)
+        rbs_path = calc_rbs_path(out_dir)
+
+        rbs_path.parent.mkpath unless rbs_path.parent.exist?
+        rbs_path.write(to_rbs)
+      end
+
       private
 
-      # @rbs (Array[String], Definition) -> boolish
-      def skip_insert?(lines, definition)
-        current = definition.lineno - 1
+      # @rbs (Array[String], Integer) -> boolish
+      def skip_insert?(lines, current)
         prev = current - 1
 
-        definition.decls.empty? ||
-          lines[prev]&.include?("# @rbs") ||
+        lines[prev]&.include?("# @rbs") ||
           lines[prev]&.include?("#:") ||
           lines[current]&.include?("#:")
       end
 
-      # @rbs () -> Enumerator[Definition, void]
-      def reverse_definitions
-        @definitions.values.sort_by { |d| -d.lineno }
+      # @rbs (Class | Module) -> (AST::Declarations::Class | AST::Declarations::Module)?
+      def find_or_new_receiver_decl(klass)
+        return unless klass.name
+        return if klass.name.is_a?(Symbol)
+
+        # Remove anonymous class names
+        class_name = klass.name.to_s.split("::").grep_v(/^#/).join("::")
+        name = TypeName.parse(class_name)
+
+        @decls[name.absolute!] ||= klass.is_a?(Class) ? new_class_decl(name:) : new_module_decl(name:)
+      end
+
+      # @rbs (String) -> Pathname
+      def calc_rbs_path(out_dir)
+        rb_path = Pathname(@path).sub(Pathname.pwd.to_s, "")
+        rb_path = rb_path.relative_path_from("/") if rb_path.absolute?
+        rbs_path = rb_path.sub_ext(".rbs")
+
+        Pathname(out_dir) + rbs_path
       end
     end
   end

data/lib/rbs/trace/helpers.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RBS
+  class Trace
+    module Helpers
+      # @rbs (name: TypeName) -> AST::Declarations::Module
+      def new_module_decl(name:)
+        AST::Declarations::Module.new(
+          name:,
+          type_params: [],
+          self_types: [],
+          members: [],
+          annotations: [],
+          location: nil,
+          comment: nil
+        )
+      end
+
+      # @rbs (name: TypeName) -> AST::Declarations::Class
+      def new_class_decl(name:)
+        AST::Declarations::Class.new(
+          name:,
+          type_params: [],
+          super_class: nil,
+          members: [],
+          annotations: [],
+          location: nil,
+          comment: nil
+        )
+      end
+
+      # @rbs (name: Symbol, kind: (:singleton | :instance)) -> AST::Members::MethodDefinition
+      def new_method_definition(name:, kind:)
+        AST::Members::MethodDefinition.new(
+          name:,
+          kind:,
+          overloads: [],
+          annotations: [],
+          location: nil,
+          comment: nil,
+          overloading: false,
+          visibility: nil
+        )
+      end
+
+      # @rbs () -> Types::Bases::Void
+      def type_void
+        @type_void = Types::Bases::Void.new(location: nil)
+      end
+
+      # @rbs () -> Types::Bases::Nil
+      def type_nil
+        @type_nil ||= Types::Bases::Nil.new(location: nil)
+      end
+
+      # @rbs () -> Types::Bases::Bool
+      def type_bool
+        @type_bool ||= Types::Bases::Bool.new(location: nil)
+      end
+
+      # @rbs () -> Types::Bases::Any
+      def type_untyped
+        @type_untyped ||= Types::Bases::Any.new(location: nil)
+      end
+    end
+  end
+end

data/lib/rbs/trace/inline_comment_visitor.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RBS
+  class Trace
+    class InlineCommentVisitor < Prism::Visitor
+      # @rbs (Hash[TypeName, AST::Declarations::t], Hash[Integer, String]) -> void
+      def initialize(decls, comments)
+        @decls = decls
+        @comments = comments
+        @context = [] #: Array[Symbol]
+
+        super()
+      end
+
+      # @rbs override
+      # @rbs (Prism::Node) -> void
+      def visit_class_node(node)
+        @context.push(node.name)
+        super
+        @context.pop
+      end
+
+      # @rbs override
+      # @rbs (Prism::Node) -> void
+      def visit_module_node(node)
+        @context.push(node.name)
+        super
+        @context.pop
+      end
+
+      # @rbs override
+      # @rbs (Prism::Node) -> void
+      def visit_def_node(node)
+        member = find_method_definition(node.name)
+        if member
+          lineno = node.location.start_line - 1
+          indent = " " * node.location.start_column
+          overloads = OverloadCompact.new(member.overloads).call
+          comment = overloads.map(&:method_type).join(" | ")
+
+          @comments[lineno] = "#{indent}# @rbs #{comment}\n"
+        end
+
+        super
+      end
+
+      private
+
+      # @rbs (Symbol) -> AST::Members::MethodDefinition?
+      def find_method_definition(name)
+        return if @context.empty?
+
+        type_name = TypeName.parse("::#{@context.join("::")}")
+        decl = @decls[type_name]
+        return unless decl
+
+        decl.members.find do |member|
+          member.is_a?(AST::Members::MethodDefinition) && member.name == name
+        end
+      end
+    end
+  end
+end

data/lib/rbs/trace/overload_compact.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module RBS
+  class Trace
+    class OverloadCompact
+      # @rbs (Array[AST::Members::MethodDefinition::Overload]) -> void
+      def initialize(overloads)
+        @overloads = overloads
+      end
+
+      # @rbs () -> Array[AST::Members::MethodDefinition::Overload]
+      def call
+        method_type = merge_method_types(@overloads.map(&:method_type))
+        [AST::Members::MethodDefinition::Overload.new(method_type:, annotations: [])]
+      end
+
+      private
+
+      # @rbs (Array[MethodType]) -> MethodType
+      def merge_method_types(method_types) # rubocop:disable Metrics
+        # steep:ignore:start
+        base = method_types.first
+        return base if method_types.one?
+
+        required_positionals = base.type.required_positionals.map.with_index do |_, i|
+          types = method_types.map { |method_type| method_type.type.required_positionals[i].type }.uniq
+          Types::Function::Param.new(name: nil, type: merge_types(types))
+        end
+
+        optional_positionals = base.type.optional_positionals.map.with_index do |_, i|
+          types = method_types.map { |method_type| method_type.type.optional_positionals[i].type }.uniq
+          Types::Function::Param.new(name: nil, type: merge_types(types))
+        end
+
+        types = method_types.filter_map { |method_type| method_type.type.rest_positionals }.uniq
+        rest_positionals = Types::Function::Param.new(name: nil, type: merge_types(types)) unless types.empty?
+
+        required_keywords = base.type.required_keywords.keys.to_h do |key|
+          types = method_types.map { |method_type| method_type.type.required_keywords[key] }.uniq
+          [key, Types::Function::Param.new(name: nil, type: merge_types(types))]
+        end
+
+        optional_keywords = base.type.optional_keywords.keys.to_h do |key|
+          types = method_types.map { |method_type| method_type.type.optional_keywords[key] }.uniq
+          [key, Types::Function::Param.new(name: nil, type: merge_types(types))]
+        end
+
+        types = method_types.filter_map { |method_type| method_type.type.rest_keywords }.uniq
+        rest_keywords = Types::Function::Param.new(name: nil, type: merge_types(types)) unless types.empty?
+
+        return_types = method_types.map { |method_type| method_type.type.return_type }.uniq
+        return_type = merge_types(return_types)
+        # steep:ignore:end
+
+        fn = Types::Function.new(
+          required_positionals:,
+          optional_positionals:,
+          rest_positionals:,
+          trailing_positionals: [],
+          required_keywords:,
+          optional_keywords:,
+          rest_keywords:,
+          return_type:
+        )
+        MethodType.new(
+          type_params: [],
+          type: fn,
+          block: nil,
+          location: nil
+        )
+      end
+
+      # @rbs (Array[Types::t]) -> Types::t
+      def merge_types(types)
+        types = compact_types(types)
+        return types.first if types.one?
+
+        optional = types.any?(Types::Bases::Nil)
+        types = types.reject { |type| type.is_a?(Types::Bases::Nil) }
+        type = types.one? ? types.first : Types::Union.new(types:, location: nil) #: Types::t
+
+        optional ? Types::Optional.new(type:, location: nil) : type
+      end
+
+      # @rbs (Array[Types::t]) -> Array[Types::t]
+      def compact_types(types)
+        types = types.reject { |t| t.is_a?(Types::Bases::Void) } if types.any? { |t| !t.is_a?(Types::Bases::Void) }
+        types.reject! { |t| t.is_a?(Types::Bases::Any) } if types.any? { |t| !t.is_a?(Types::Bases::Any) }
+        types
+      end
+    end
+  end
+end

data/lib/rbs/trace/return_value_visitor.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module RBS
+  class Trace
+    class ReturnValueVisitor < Prism::BasicVisitor
+      class << self
+        # @rbs (String) -> ReturnValueVisitor
+        def parse_file(path)
+          new.tap do |visitor|
+            result = Prism.parse_file(path)
+            visitor.visit(result.value)
+          end
+        end
+      end
+
+      # @void_types: Hash[Array[Integer, Symbol], bool]
+      # @parents: Array[Prism::Node]
+
+      # @rbs () -> void
+      def initialize
+        @void_types = {} #: Hash[Array[Integer|Symbol], bool]
+        @parents = [] #: Array[Prism::Node]
+        super
+      end
+
+      # @rbs (Integer, Symbol) -> bool
+      def void_type?(lineno, name)
+        @void_types.fetch([lineno, name], false)
+      end
+
+      # @rbs (Prism::Node) -> void
+      def visit_child_nodes(node)
+        @parents.push(node)
+        super
+        @parents.pop
+      end
+
+      # @rbs (Prism::CallNode) -> void
+      def visit_call_node(node)
+        key = [node.location.start_line, node.name]
+        @void_types[key] = void?(node)
+
+        visit_child_nodes(node)
+      end
+
+      (Prism::Visitor.instance_methods.grep(/^visit_/) - instance_methods).each do |m|
+        alias_method(m, :visit_child_nodes)
+      end
+
+      private
+
+      # @rbs (Prism::CallNode) -> bool
+      def void?(node)
+        parent_node = @parents[-1]
+        next_parent_node = @parents[-2]
+        return true if parent_node.nil? || next_parent_node.nil?
+
+        if next_parent_node.type == :program_node
+          parent_node.type == :statements_node
+        else
+          parent_node.type == :statements_node && parent_node.child_nodes[-1] != node
+        end
+      end
+    end
+  end
+end

data/lib/rbs/trace/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module RBS
-  module Trace
-    VERSION = "0.3.2"
+  class Trace
+    VERSION = "0.4.1"
   end
 end

data/lib/rbs/trace.rb

@@ -2,16 +2,168 @@
 
 require "bundler"
 require "logger"
+require "optparse"
 require "prism"
+require "rbs"
 
-require_relative "trace/declaration"
-require_relative "trace/definition"
+require_relative "trace/helpers"
+require_relative "trace/builder"
+require_relative "trace/cli"
+require_relative "trace/cli/inline"
+require_relative "trace/cli/merge"
 require_relative "trace/file"
-require_relative "trace/method_tracing"
+require_relative "trace/inline_comment_visitor"
+require_relative "trace/overload_compact"
+require_relative "trace/return_value_visitor"
 require_relative "trace/version"
 
 module RBS
-  module Trace
+  class Trace
     class Error < StandardError; end
+    # steep:ignore:start
+    BUNDLE_PATH = Bundler.bundle_path.to_s #: String
+    # steep:ignore:end
+    RUBY_LIB_PATH = RbConfig::CONFIG["rubylibdir"] #: String
+    PATH_INTERNAL = "<internal" #: String
+    PATH_EVAL = "(eval" #: String
+    PATH_INLINE_TEMPLATE = "inline template" #: String
+
+    private_constant :BUNDLE_PATH, :RUBY_LIB_PATH, :PATH_INTERNAL, :PATH_EVAL, :PATH_INLINE_TEMPLATE
+
+    # @rbs (?log_level: Symbol, ?raises: bool) -> void
+    def initialize(log_level: nil, raises: false)
+      @log_level = log_level
+      @log_level ||= ENV["RBS_TRACE_DEBUG"] ? :debug : :info
+      @raises = raises
+    end
+
+    # @rbs [T] () { () -> T } -> T
+    def enable(&)
+      trace.enable(&)
+    end
+
+    # @rbs () -> void
+    def disable
+      trace.disable
+    end
+
+    # @rbs () -> Hash[String, File]
+    def files
+      @files ||= {}
+    end
+
+    # @rbs () -> void
+    def save_comments
+      files.each_value(&:rewrite)
+    end
+
+    # @rbs (out_dir: String) -> void
+    def save_files(out_dir:)
+      files.each_value { |file| file.save_rbs(out_dir) }
+    end
+
+    private
+
+    # @rbs () -> TracePoint
+    def trace
+      @trace ||= TracePoint.new(:call, :return) { |tp| record(tp) }
+    end
+
+    # @rbs () -> Logger
+    def logger
+      @logger ||= Logger.new($stdout, level: @log_level)
+    end
+
+    # @rbs () -> Builder
+    def builder
+      @builder ||= Builder.new
+    end
+
+    # @rbs (String) -> File
+    def find_or_new_file(path)
+      files[path] ||= File.new(path)
+    end
+
+    # @rbs (TracePoint) -> void
+    def record(tp) # rubocop:disable Metrics/MethodLength
+      return if ignore_path?(tp.path)
+
+      file = find_or_new_file(tp.path)
+      # steep:ignore:start
+      member = file.find_or_new_method_definition(tp.self, tp.defined_class, tp.method_id)
+      # steep:ignore:end
+      return unless member
+
+      case tp.event
+      when :call
+        call_event(tp, member)
+      when :return
+        return_event(tp, member)
+      end
+    rescue StandardError => e
+      logger.debug(e)
+      raise(e) if @raises
+    end
+
+    # @rbs (TracePoint, AST::Members::MethodDefinition) -> void
+    def call_event(tp, member)
+      # steep:ignore:start
+      void = member.overloads.all? { |overload| overload.method_type.type.return_type.is_a?(Types::Bases::Void) } &&
+             void_return_type?(tp.path, tp.method_id)
+
+      builder.method_call(
+        bind: tp.binding,
+        parameters: tp.parameters,
+        void:
+      )
+      # steep:ignore:end
+    end
+
+    # @rbs (TracePoint, AST::Members::MethodDefinition) -> void
+    def return_event(tp, member)
+      overload = builder.method_return(tp.return_value)
+      return if member.overloads.include?(overload)
+
+      member.overloads << overload
+    end
+
+    # @rbs (String) -> bool
+    def ignore_path?(path)
+      path.start_with?(
+        PATH_INTERNAL,
+        PATH_EVAL,
+        PATH_INLINE_TEMPLATE,
+        BUNDLE_PATH,
+        RUBY_LIB_PATH,
+        __FILE__
+      )
+    end
+
+    # @rbs (String, Symbol) -> bool
+    def void_return_type?(path, method_id)
+      return true if method_id == :initialize
+
+      loc = find_caller_location(path, method_id.to_s)
+      # If the caller is not found, assume the return value is used.
+      return false unless loc
+
+      caller_path = loc.path.to_s
+      # Returns true if the file does not exist (eval, etc.)
+      return true unless ::File.exist?(caller_path)
+
+      # If the file is not Ruby, assume the return value is used. (erb, haml, etc.)
+      return false if ::File.extname(caller_path) != ".rb"
+
+      @return_value_visitors ||= {} #: Hash[String, ReturnValueVisitor]
+      v = @return_value_visitors.fetch(caller_path) { ReturnValueVisitor.parse_file(caller_path) }
+      v.void_type?(loc.lineno, method_id)
+    end
+
+    # @rbs (String, String) -> Thread::Backtrace::Location?
+    def find_caller_location(path, label)
+      locations = caller_locations || []
+      i = locations.index { |loc| loc.path == path && loc.label == label }
+      locations[i + 1] if i
+    end
   end
 end

data/rbs_collection.lock.yaml

@@ -49,10 +49,6 @@ gems:
   version: 3.8.1
   source:
     type: rubygems
-- name: rbs-inline
-  version: 0.10.0
-  source:
-    type: rubygems
 - name: rdoc
   version: '0'
   source:

data/sig/generated/rbs/trace/builder.rbs

@@ -0,0 +1,40 @@
+# Generated from lib/rbs/trace/builder.rb with RBS::Inline
+
+module RBS
+  class Trace
+    class Builder
+      include Helpers
+
+      UNBOUND_CLASS_METHOD: untyped
+
+      UNBOUND_NAME_METHOD: untyped
+
+      GENERICS_SIZE: untyped
+
+      # @rbs (bind: Binding, parameters: Array[__todo__], void: bool) -> Array[__todo__]
+      def method_call: (bind: Binding, parameters: Array[__todo__], void: bool) -> Array[__todo__]
+
+      # @rbs (__todo__) -> AST::Members::MethodDefinition::Overload
+      def method_return: (__todo__) -> AST::Members::MethodDefinition::Overload
+
+      private
+
+      def stack_traces: () -> untyped
+
+      # @rbs (Binding, Array[__todo__]) -> MethodType
+      def parse_parameters: (Binding, Array[__todo__]) -> MethodType
+
+      # @rbs (Array[untyped]) -> Types::t
+      def parse_classes: (Array[untyped]) -> Types::t
+
+      # @rbs (untyped) -> Types::t
+      def parse_class: (untyped) -> Types::t
+
+      # @rbs (BasicObject) -> Types::t
+      def parse_object: (BasicObject) -> Types::t
+
+      # @rbs (BasicObject) -> Class
+      def obj_to_class: (BasicObject) -> Class
+    end
+  end
+end

data/sig/generated/rbs/trace/cli/inline.rbs

@@ -0,0 +1,19 @@
+# Generated from lib/rbs/trace/cli/inline.rb with RBS::Inline
+
+module RBS
+  class Trace
+    class CLI
+      class Inline
+        BANNER: ::String
+
+        # @rbs (Array[String]) -> void
+        def run: (Array[String]) -> void
+
+        private
+
+        # @rbs (String) -> Environment
+        def load_env: (String) -> Environment
+      end
+    end
+  end
+end

data/sig/generated/rbs/trace/cli/merge.rbs

@@ -0,0 +1,24 @@
+# Generated from lib/rbs/trace/cli/merge.rb with RBS::Inline
+
+module RBS
+  class Trace
+    class CLI
+      class Merge
+        BANNER: ::String
+
+        # @rbs (Array[String]) -> void
+        def run: (Array[String]) -> void
+
+        # @rbs (Array[Environment]) -> Environment
+        def merge_envs: (Array[Environment]) -> Environment
+
+        private
+
+        # @rbs (String) -> Environment
+        def load_env: (String) -> Environment
+
+        def merge: (untyped decl, untyped member) -> untyped
+      end
+    end
+  end
+end