rbs-trace 0.3.2 → 0.4.0

data/lib/rbs/trace/helpers.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module RBS
+  class Trace
+    module Helpers
+      UNBOUND_CLASS_METHOD = Object.instance_method(:class)
+      private_constant :UNBOUND_CLASS_METHOD
+
+      # @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 (BasicObject) -> Class
+      def obj_to_class(obj)
+        UNBOUND_CLASS_METHOD.bind_call(obj)
+      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,85 @@
+# 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)
+        return types.first if types.one?
+
+        optional = types.any? { |type| type.is_a?(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
+    end
+  end
+end

data/lib/rbs/trace/return_value_visitor.rb

@@ -0,0 +1,63 @@
+# 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] = !use_return_value?(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 use_return_value?(_node)
+        parent_type = @parents[-1]&.type
+        next_parent_type = @parents[-2]&.type
+
+        parent_type.end_with?("write_node") ||
+          parent_type == :call_node ||
+          (parent_type == :statements_node && next_parent_type == :embedded_statements_node)
+      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.0"
   end
 end

data/lib/rbs/trace.rb

@@ -2,16 +2,165 @@
 
 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)
+
+      @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,33 @@
+# Generated from lib/rbs/trace/builder.rb with RBS::Inline
+
+module RBS
+  class Trace
+    class Builder
+      include Helpers
+
+      GENERICS_SIZE: untyped
+
+      # @rbs (bind: Binding, parameters: Array[__todo__], void: bool) -> void
+      def method_call: (bind: Binding, parameters: Array[__todo__], void: bool) -> void
+
+      # @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
+    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

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

@@ -0,0 +1,17 @@
+# Generated from lib/rbs/trace/cli.rb with RBS::Inline
+
+module RBS
+  class Trace
+    class CLI
+      BANNER: ::String
+
+      # @rbs (Array[String]) -> void
+      def run: (Array[String]) -> void
+
+      private
+
+      # @rbs (Symbol?) -> (singleton(Inline) | singleton(Merge))?
+      def command_class: (Symbol?) -> (singleton(Inline) | singleton(Merge))?
+    end
+  end
+end

data/sig/generated/rbs/trace/file.rbs

@@ -1,13 +1,15 @@
 # Generated from lib/rbs/trace/file.rb with RBS::Inline
 
 module RBS
-  module Trace
+  class Trace
     class File
-      # @rbs (String) -> void
-      def initialize: (String) -> void
+      include Helpers
+
+      # @rbs (String, ?Hash[TypeName, AST::Declarations::t]) -> void
+      def initialize: (String, ?Hash[TypeName, AST::Declarations::t]) -> void
 
-      # @rbs () -> Hash[String, Definition]
-      def definitions: () -> Hash[String, Definition]
+      # @rbs (untyped, Class, Symbol) -> AST::Members::MethodDefinition?
+      def find_or_new_method_definition: (untyped, Class, Symbol) -> AST::Members::MethodDefinition?
 
       # @rbs () -> String
       def with_rbs: () -> String
@@ -15,13 +17,22 @@ module RBS
       # @rbs () -> void
       def rewrite: () -> void
 
+      # @rbs () -> String
+      def to_rbs: () -> String
+
+      # @rbs (String) -> void
+      def save_rbs: (String) -> void
+
       private
 
-      # @rbs (Array[String], Definition) -> boolish
-      def skip_insert?: (Array[String], Definition) -> boolish
+      # @rbs (Array[String], Integer) -> boolish
+      def skip_insert?: (Array[String], Integer) -> boolish
+
+      # @rbs (Class | Module) -> (AST::Declarations::Class | AST::Declarations::Module)?
+      def find_or_new_receiver_decl: (Class | Module) -> (AST::Declarations::Class | AST::Declarations::Module)?
 
-      # @rbs () -> Enumerator[Definition, void]
-      def reverse_definitions: () -> Enumerator[Definition, void]
+      # @rbs (String) -> Pathname
+      def calc_rbs_path: (String) -> Pathname
     end
   end
 end

data/sig/generated/rbs/trace/helpers.rbs

@@ -0,0 +1,33 @@
+# Generated from lib/rbs/trace/helpers.rb with RBS::Inline
+
+module RBS
+  class Trace
+    module Helpers
+      UNBOUND_CLASS_METHOD: untyped
+
+      # @rbs (name: TypeName) -> AST::Declarations::Module
+      def new_module_decl: (name: TypeName) -> AST::Declarations::Module
+
+      # @rbs (name: TypeName) -> AST::Declarations::Class
+      def new_class_decl: (name: TypeName) -> AST::Declarations::Class
+
+      # @rbs (name: Symbol, kind: (:singleton | :instance)) -> AST::Members::MethodDefinition
+      def new_method_definition: (name: Symbol, kind: :singleton | :instance) -> AST::Members::MethodDefinition
+
+      # @rbs (BasicObject) -> Class
+      def obj_to_class: (BasicObject) -> Class
+
+      # @rbs () -> Types::Bases::Void
+      def type_void: () -> Types::Bases::Void
+
+      # @rbs () -> Types::Bases::Nil
+      def type_nil: () -> Types::Bases::Nil
+
+      # @rbs () -> Types::Bases::Bool
+      def type_bool: () -> Types::Bases::Bool
+
+      # @rbs () -> Types::Bases::Any
+      def type_untyped: () -> Types::Bases::Any
+    end
+  end
+end

data/sig/generated/rbs/trace/inline_comment_visitor.rbs

@@ -0,0 +1,27 @@
+# Generated from lib/rbs/trace/inline_comment_visitor.rb with RBS::Inline
+
+module RBS
+  class Trace
+    class InlineCommentVisitor < Prism::Visitor
+      # @rbs (Hash[TypeName, AST::Declarations::t], Hash[Integer, String]) -> void
+      def initialize: (Hash[TypeName, AST::Declarations::t], Hash[Integer, String]) -> void
+
+      # @rbs override
+      # @rbs (Prism::Node) -> void
+      def visit_class_node: ...
+
+      # @rbs override
+      # @rbs (Prism::Node) -> void
+      def visit_module_node: ...
+
+      # @rbs override
+      # @rbs (Prism::Node) -> void
+      def visit_def_node: ...
+
+      private
+
+      # @rbs (Symbol) -> AST::Members::MethodDefinition?
+      def find_method_definition: (Symbol) -> AST::Members::MethodDefinition?
+    end
+  end
+end