steep-relaxed 1.9.3.3

data/lib/steep/typing.rb

@@ -0,0 +1,321 @@
+module Steep
+  class Typing
+    class UnknownNodeError < StandardError
+      attr_reader :op
+      attr_reader :node
+
+      def initialize(op, node:)
+        @op = op
+        @node = node
+        super "Unknown node for #{op}: #{node.inspect}"
+      end
+    end
+
+    class CursorContext
+      attr_reader :index
+
+      attr_reader :data
+
+      def initialize(index)
+        @index = index
+      end
+
+      def set(range, context = nil)
+        if range.is_a?(CursorContext)
+          range, context = range.data
+          range or return
+          context or return
+        end
+
+        context or raise
+        return unless index
+
+        if current_range = self.range
+          if range.begin <= index && index <= range.end
+            if current_range.begin <= range.begin && range.end <= current_range.end
+              @data = [range, context]
+            end
+          end
+        else
+          @data = [range, context]
+        end
+      end
+
+      def set_node_context(node, context)
+        begin_pos = node.loc.expression.begin_pos
+        end_pos = node.loc.expression.end_pos
+
+        set(begin_pos..end_pos, context)
+      end
+
+      def set_body_context(node, context)
+        case node.type
+        when :class
+          name_node, super_node, _ = node.children
+          begin_pos = if super_node
+                        super_node.loc.expression.end_pos
+                      else
+                        name_node.loc.expression.end_pos
+                      end
+          end_pos = node.loc.end.begin_pos # steep:ignore NoMethod
+
+          set(begin_pos..end_pos, context)
+
+        when :module
+          name_node = node.children[0]
+          begin_pos = name_node.loc.expression.end_pos
+          end_pos = node.loc.end.begin_pos # steep:ignore NoMethod
+          set(begin_pos..end_pos, context)
+
+        when :sclass
+          name_node = node.children[0]
+          begin_pos = name_node.loc.expression.end_pos
+          end_pos = node.loc.end.begin_pos # steep:ignore NoMethod
+          set(begin_pos..end_pos, context)
+
+        when :def, :defs
+          if node.children.last
+            args_node =
+              case node.type
+              when :def
+                node.children[1]
+              when :defs
+                node.children[2]
+              end
+
+            body_begin_pos =
+              case
+              when node.loc.assignment # steep:ignore NoMethod
+                # endless def
+                node.loc.assignment.end_pos # steep:ignore NoMethod
+              when args_node.loc.expression
+                # with args
+                args_node.loc.expression.end_pos
+              else
+                # without args
+                node.loc.name.end_pos # steep:ignore NoMethod
+              end
+
+            body_end_pos =
+              if node.loc.end # steep:ignore NoMethod
+                node.loc.end.begin_pos # steep:ignore NoMethod
+              else
+                node.loc.expression.end_pos
+              end
+
+            set(body_begin_pos..body_end_pos, context)
+          end
+
+        when :block, :numblock
+          range = block_range(node)
+          set(range, context)
+
+        when :for
+          _, collection, _ = node.children
+
+          begin_pos = collection.loc.expression.end_pos
+          end_pos = node.loc.end.begin_pos # steep:ignore NoMethod
+
+          set(begin_pos..end_pos, context)
+        else
+          raise "Unexpected node for insert_context: #{node.type}"
+        end
+      end
+
+      def block_range(node)
+        case node.type
+        when :block
+          send_node, args_node, _ = node.children
+          begin_pos = if send_node.type != :lambda && args_node.loc.expression
+                        args_node.loc.expression.end_pos
+                      else
+                        node.loc.begin.end_pos # steep:ignore NoMethod
+                      end
+          end_pos = node.loc.end.begin_pos # steep:ignore NoMethod
+        when :numblock
+          send_node, _ = node.children
+          begin_pos = node.loc.begin.end_pos # steep:ignore NoMethod
+          end_pos = node.loc.end.begin_pos # steep:ignore NoMethod
+        end
+
+        begin_pos..end_pos
+      end
+
+      def range
+        range, _ = data
+        range
+      end
+
+      def context
+        _, context = data
+        context
+      end
+    end
+
+    attr_reader :source
+    attr_reader :errors
+    attr_reader :typing
+    attr_reader :parent
+    attr_reader :parent_last_update
+    attr_reader :last_update
+    attr_reader :should_update
+    attr_reader :contexts
+    attr_reader :root_context
+    attr_reader :method_calls
+    attr_reader :source_index
+    attr_reader :cursor_context
+
+    def initialize(source:, root_context:, parent: nil, parent_last_update: parent&.last_update, source_index: nil, cursor:)
+      @source = source
+
+      @parent = parent
+      @parent_last_update = parent_last_update
+      @last_update = parent&.last_update || 0
+      @should_update = false
+
+      @errors = []
+      (@typing = {}).compare_by_identity
+      @root_context = root_context
+      (@method_calls = {}).compare_by_identity
+
+      @cursor_context = CursorContext.new(cursor)
+      if root_context
+        cursor_context.set(0..source.buffer.content&.size || 0, root_context)
+      end
+
+      @source_index = source_index || Index::SourceIndex.new(source: source)
+    end
+
+    def add_error(error)
+      errors << error
+    end
+
+    def add_typing(node, type, _context)
+      typing[node] = type
+      @last_update += 1
+
+      type
+    end
+
+    def add_call(node, call)
+      method_calls[node] = call
+
+      call
+    end
+
+    def has_type?(node)
+      typing.key?(node)
+    end
+
+    def type_of(node:)
+      raise "`nil` given to `Typing#type_of(node:)`" unless node
+
+      type = typing[node]
+
+      if type
+        type
+      else
+        if parent
+          parent.type_of(node: node)
+        else
+          raise UnknownNodeError.new(:type, node: node)
+        end
+      end
+    end
+
+    def call_of(node:)
+      call = method_calls[node]
+
+      if call
+        call
+      else
+        if parent
+          parent.call_of(node: node)
+        else
+          raise UnknownNodeError.new(:call, node: node)
+        end
+      end
+    end
+
+    def block_range(node)
+      case node.type
+      when :block
+        send_node, args_node, _ = node.children
+        begin_pos = if send_node.type != :lambda && args_node.loc.expression
+                      args_node.loc.expression.end_pos
+                    else
+                      node.loc.begin.end_pos # steep:ignore NoMethod
+                    end
+        end_pos = node.loc.end.begin_pos # steep:ignore NoMethod
+      when :numblock
+        send_node, _ = node.children
+        begin_pos = node.loc.begin.end_pos # steep:ignore NoMethod
+        end_pos = node.loc.end.begin_pos # steep:ignore NoMethod
+      end
+
+      begin_pos..end_pos
+    end
+
+    def dump(io)
+      # steep:ignore:start
+      io.puts "Typing: "
+      nodes.each_value do |node|
+        io.puts "  #{Typing.summary(node)} => #{type_of(node: node).inspect}"
+      end
+
+      io.puts "Errors: "
+      errors.each do |error|
+        io.puts "  #{Typing.summary(error.node)} => #{error.inspect}"
+      end
+      # steep:ignore:end
+    end
+
+    def self.summary(node)
+      src = node.loc.expression.source.split(/\n/).first
+      line = node.loc.first_line
+      col = node.loc.column
+
+      "#{line}:#{col}:#{src}"
+    end
+
+    def new_child()
+      child = self.class.new(
+        source: source,
+        parent: self,
+        root_context: root_context,
+        source_index: source_index.new_child,
+        cursor: cursor_context.index
+      )
+      @should_update = true
+
+      if block_given?
+        yield child
+      else
+        child
+      end
+    end
+
+    def each_typing(&block)
+      typing.each(&block)
+    end
+
+    def save!
+      raise "Unexpected save!" unless parent
+      raise "Parent modified since #new_child: parent.last_update=#{parent.last_update}, parent_last_update=#{parent_last_update}" unless parent.last_update == parent_last_update
+
+      each_typing do |node, type|
+        parent.add_typing(node, type, nil)
+      end
+
+      parent.method_calls.merge!(method_calls)
+
+      errors.each do |error|
+        parent.add_error error
+      end
+
+      parent.cursor_context.set(cursor_context)
+
+      parent.source_index.merge!(source_index)
+    end
+  end
+end

data/lib/steep/version.rb

@@ -0,0 +1,3 @@
+module Steep
+  VERSION = "1.9.3.3"
+end

data/lib/steep.rb

@@ -0,0 +1,369 @@
+require "steep/version"
+
+require "pathname"
+require "parser/ruby33"
+require "active_support"
+require "active_support/core_ext/object/try"
+require "active_support/core_ext/string/inflections"
+require "logger"
+require "rainbow"
+require "listen"
+require 'language_server-protocol'
+require "etc"
+require "open3"
+require "stringio"
+require 'uri'
+require "yaml"
+require "securerandom"
+require "base64"
+require "time"
+
+require "concurrent/utility/processor_counter"
+require "terminal-table"
+
+require "rbs"
+
+require "steep/path_helper"
+require "steep/located_value"
+require "steep/thread_waiter"
+require "steep/equatable"
+require "steep/method_name"
+require "steep/node_helper"
+require "steep/ast/types/shared_instance"
+require "steep/ast/types/helper"
+require "steep/ast/types/any"
+require "steep/ast/types/instance"
+require "steep/ast/types/class"
+require "steep/ast/types/union"
+require "steep/ast/types/var"
+require "steep/ast/types/name"
+require "steep/ast/types/self"
+require "steep/ast/types/intersection"
+require "steep/ast/types/void"
+require "steep/ast/types/bot"
+require "steep/ast/types/top"
+require "steep/ast/types/nil"
+require "steep/ast/types/literal"
+require "steep/ast/types/boolean"
+require "steep/ast/types/tuple"
+require "steep/ast/types/proc"
+require "steep/ast/types/record"
+require "steep/ast/types/logic"
+require "steep/ast/annotation"
+require "steep/ast/annotation/collection"
+require "steep/ast/node/type_assertion"
+require "steep/ast/node/type_application"
+require "steep/ast/builtin"
+require "steep/ast/types/factory"
+require "steep/ast/ignore"
+
+require "steep/range_extension"
+
+require "steep/interface/type_param"
+require "steep/interface/function"
+require "steep/interface/block"
+require "steep/interface/method_type"
+require "steep/interface/substitution"
+require "steep/interface/shape"
+require "steep/interface/builder"
+
+require "steep/subtyping/result"
+require "steep/subtyping/check"
+require "steep/subtyping/cache"
+require "steep/subtyping/relation"
+require "steep/subtyping/constraints"
+require "steep/subtyping/variable_variance"
+
+require "steep/diagnostic/helper"
+require "steep/diagnostic/result_printer2"
+require "steep/diagnostic/ruby"
+require "steep/diagnostic/signature"
+require "steep/diagnostic/lsp_formatter"
+require "steep/signature/validator"
+require "steep/module_helper"
+require "steep/source"
+require "steep/source/ignore_ranges"
+require "steep/annotation_parser"
+require "steep/typing"
+require "steep/type_construction"
+require "steep/type_inference/context"
+require "steep/type_inference/send_args"
+require "steep/type_inference/block_params"
+require "steep/type_inference/method_params"
+require "steep/type_inference/constant_env"
+require "steep/type_inference/type_env"
+require "steep/type_inference/type_env_builder"
+require "steep/type_inference/logic_type_interpreter"
+require "steep/type_inference/multiple_assignment"
+require "steep/type_inference/method_call"
+require "steep/type_inference/case_when"
+
+require "steep/index/rbs_index"
+require "steep/index/signature_symbol_provider"
+require "steep/index/source_index"
+
+require "steep/services/content_change"
+require "steep/services/path_assignment"
+require "steep/services/signature_service"
+require "steep/services/type_check_service"
+require "steep/services/hover_provider/singleton_methods"
+require "steep/services/hover_provider/ruby"
+require "steep/services/hover_provider/rbs"
+require "steep/services/type_name_completion"
+require "steep/services/completion_provider"
+require "steep/services/signature_help_provider"
+require "steep/services/stats_calculator"
+require "steep/services/file_loader"
+require "steep/services/goto_service"
+
+require "steep/server/custom_methods"
+require "steep/server/work_done_progress"
+require "steep/server/delay_queue"
+require "steep/server/lsp_formatter"
+require "steep/server/change_buffer"
+require "steep/server/base_worker"
+require "steep/server/worker_process"
+require "steep/server/interaction_worker"
+require "steep/server/type_check_worker"
+require "steep/server/target_group_files"
+require "steep/server/type_check_controller"
+require "steep/server/master"
+
+require "steep/project"
+require "steep/project/pattern"
+require "steep/project/options"
+require "steep/project/target"
+require "steep/project/group"
+require "steep/project/dsl"
+
+require "steep/expectations"
+require "steep/drivers/utils/driver_helper"
+require "steep/drivers/utils/jobs_option"
+require "steep/drivers/check"
+require "steep/drivers/checkfile"
+require "steep/drivers/stats"
+require "steep/drivers/annotations"
+require "steep/drivers/watch"
+require "steep/drivers/langserver"
+require "steep/drivers/print_project"
+require "steep/drivers/init"
+require "steep/drivers/vendor"
+require "steep/drivers/worker"
+require "steep/drivers/diagnostic_printer"
+
+if ENV["NO_COLOR"]
+  Rainbow.enabled = false
+end
+
+$stderr = STDERR
+
+module Steep
+  def self.logger
+    @logger || raise
+  end
+
+  def self.ui_logger
+    @ui_logger || raise
+  end
+
+  def self.new_logger(output, prev_level)
+    logger = Logger.new(output)
+    logger.formatter = proc do |severity, datetime, progname, msg|
+      # @type var severity: String
+      # @type var datetime: Time
+      # @type var progname: untyped
+      # @type var msg: untyped
+      # @type block: String
+      "#{datetime.strftime('%Y-%m-%d %H:%M:%S.%L')}: #{severity}: #{msg}\n"
+    end
+    ActiveSupport::TaggedLogging.new(logger).tap do |logger|
+      logger.push_tags "Steep #{VERSION}"
+      logger.level = prev_level || Logger::ERROR
+    end
+  end
+
+  def self.log_output
+    @log_output
+  end
+
+  def self.log_output=(output)
+    @log_output = output
+
+    prev_level = @logger&.level
+    @logger = new_logger(output, prev_level)
+
+    prev_level = @ui_logger&.level
+    @ui_logger = new_logger(output, prev_level)
+
+    output
+  end
+
+  @logger = nil
+  @ui_logger = nil
+  self.log_output = STDERR
+
+  def self.measure(message, level: :warn, threshold: 0.0)
+    start = Time.now
+    begin
+      yield
+    ensure
+      time = Time.now - start
+      if level.is_a?(Symbol)
+        level = Logger.const_get(level.to_s.upcase)
+      end
+      if time > threshold
+        self.logger.log(level) { "#{message} took #{time} seconds" }
+      end
+    end
+  end
+
+  def self.log_error(exn, message: "Unexpected error: #{exn.inspect}")
+    Steep.logger.fatal message
+    if backtrace = exn.backtrace
+      backtrace.each do |loc|
+        Steep.logger.error "  #{loc}"
+      end
+    end
+  end
+
+  class Sampler
+    def initialize()
+      @samples = []
+    end
+
+    def sample(message)
+      start = Time.now
+      begin
+        yield
+      ensure
+        time = Time.now - start
+        @samples << [message, time]
+      end
+    end
+
+    def count
+      @samples.count
+    end
+
+    def total
+      @samples.sum(&:last)
+    end
+
+    def slowests(num)
+      @samples.sort_by(&:last).reverse.take(num)
+    end
+
+    def average
+      if count > 0
+        total/count
+      else
+        0.to_f
+      end
+    end
+
+    def percentile(p)
+      c = [count * p / 100.to_r, 1].max or raise
+      slowests(c.to_i).last&.last || 0.to_f
+    end
+  end
+
+  def self.measure2(message, level: :warn)
+    sampler = Sampler.new
+    result = yield(sampler)
+
+    if level.is_a?(Symbol)
+      level = Logger.const_get(level.to_s.upcase)
+    end
+    logger.log(level) { "#{sampler.total}secs for \"#{message}\"" }
+    logger.log(level) { "  Average: #{sampler.average}secs"}
+    logger.log(level) { "  Median: #{sampler.percentile(50)}secs"}
+    logger.log(level) { "  Samples: #{sampler.count}"}
+    logger.log(level) { "  99 percentile: #{sampler.percentile(99)}secs"}
+    logger.log(level) { "  90 percentile: #{sampler.percentile(90)}secs"}
+    logger.log(level) { "  10 Slowests:"}
+    sampler.slowests(10).each do |message, time|
+      logger.log(level) { "    #{message} (#{time}secs)"}
+    end
+
+    result
+  end
+end
+
+klasses = [
+  # Steep::Interface::MethodType
+] #: Array[Class]
+
+klasses.each do |klass|
+  klass.instance_eval do
+    def self.new(*_a, **_b, &_c)
+      super
+    end
+  end
+end
+
+module GCCounter
+  module_function
+
+  def count_objects(title, regexp = /^Steep/, skip: false)
+    if ENV["COUNT_GC_OBJECTS"] && !skip
+      unless GC.disable
+        GC.start(immediate_sweep: true, immediate_mark: true, full_mark: true)
+
+        begin
+          yield
+        ensure
+          Steep.logger.fatal "===== #{title} ==============================="
+
+          klasses = [] #: Array[Class]
+
+          ObjectSpace.each_object(Class) do |klass|
+            if (klass.name || "") =~ regexp
+              klasses << klass
+            end
+          end
+
+          before = {} #: Hash[Class, Integer]
+
+          klasses.each do |klass|
+            count = ObjectSpace.each_object(klass).count
+            before[klass] = count
+          end
+
+          GC.start(immediate_sweep: true, immediate_mark: true, full_mark: true)
+
+          gceds = [] #: Array[[Class, Integer]]
+
+          klasses.each do |klass|
+            count = ObjectSpace.each_object(klass).count
+            gced = (before[klass] || 0) - count
+
+            gceds << [klass, gced] if gced > 0
+          end
+
+          gceds.sort_by! {|_, count| -count }
+          gceds.each do |klass, count|
+            Steep.logger.fatal { "#{klass.name} => #{count}"}
+          end
+
+          GC.enable
+        end
+      else
+        yield
+      end
+    else
+      yield
+    end
+  end
+end
+
+
+
+
+# klasses = [Set]
+# klasses.each do |klass|
+#   # steep:ignore:start
+#   def klass.new(...)
+#     super
+#   end
+#   # steep:ignore:end
+# end