spoom 1.5.0 → 1.7.2

data/lib/spoom/sorbet/metrics/code_metrics_visitor.rb

@@ -0,0 +1,236 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  module Sorbet
+    module Metrics
+      class << self
+        #: (Array[String]) -> Spoom::Counters
+        def collect_code_metrics(files)
+          counters = Counters.new
+
+          files.each do |file|
+            counters.increment("files")
+
+            content = File.read(file)
+            node = Spoom.parse_ruby(content, file: file, comments: true)
+            visitor = CodeMetricsVisitor.new(counters)
+            visitor.visit(node)
+          end
+
+          counters
+        end
+      end
+
+      # Collects metrics about how Sorbet is used in the codebase.
+      #
+      # This approach is different from the metrics file we get directly from Sorbet.
+      #
+      # This visitor actually visits the codebase and collects metrics about the amount of signatures, `T.` calls,
+      # and other metrics. It also knows about RBS comments.
+      #
+      # On the other hand, the metrics file is a snapshot of the metrics at type checking time and knows about
+      # is calls are typed, how many assertions are done, etc.
+      class CodeMetricsVisitor < Spoom::Visitor
+        include RBS::ExtractRBSComments
+
+        #: Counters
+        attr_reader :counters
+
+        #: (Spoom::Counters) -> void
+        def initialize(counters)
+          super()
+
+          @counters = counters
+
+          @last_sigs = [] #: Array[Prism::CallNode]
+          @type_params = [] #: Array[Prism::CallNode]
+        end
+
+        # @override
+        #: (Prism::Node?) -> void
+        def visit(node)
+          return if node.nil?
+
+          node.location.trailing_comments.each do |comment|
+            text = comment.slice.strip
+            next unless text.start_with?("#:")
+
+            @counters.increment("rbs_assertions")
+
+            case text
+            when /^#: as !nil/
+              @counters.increment("rbs_must")
+            when /^#: as untyped/
+              @counters.increment("rbs_unsafe")
+            when /^#: as/
+              @counters.increment("rbs_cast")
+            when /^#:/
+              @counters.increment("rbs_let")
+            end
+          end
+
+          super
+        end
+
+        # @override
+        #: (Prism::ClassNode) -> void
+        def visit_class_node(node)
+          visit_scope(node) do
+            super
+          end
+        end
+
+        # @override
+        #: (Prism::ModuleNode) -> void
+        def visit_module_node(node)
+          visit_scope(node) do
+            super
+          end
+        end
+
+        # @override
+        #: (Prism::SingletonClassNode) -> void
+        def visit_singleton_class_node(node)
+          visit_scope(node) do
+            super
+          end
+        end
+
+        # @override
+        #: (Prism::DefNode) -> void
+        def visit_def_node(node)
+          unless node.name.to_s.start_with?("test_")
+            @counters.increment("methods")
+
+            rbs_sigs = node_rbs_comments(node).signatures
+            srb_sigs = collect_last_srb_sigs
+
+            if rbs_sigs.any?
+              @counters.increment("methods_with_rbs_sig")
+            end
+
+            if srb_sigs.any?
+              @counters.increment("methods_with_srb_sig")
+            end
+
+            if rbs_sigs.empty? && srb_sigs.empty?
+              @counters.increment("methods_without_sig")
+            end
+          end
+
+          super
+        end
+
+        # @override
+        #: (Prism::CallNode) -> void
+        def visit_call_node(node)
+          @counters.increment("calls")
+
+          case node.name
+          when :attr_accessor, :attr_reader, :attr_writer
+            visit_attr_accessor(node)
+            return
+          when :sig
+            visit_sig(node)
+            return
+          when :type_member, :type_template
+            visit_type_member(node)
+            return
+          end
+
+          case node.receiver&.slice
+          when /^(::)?T$/
+            @counters.increment("T_calls")
+            @counters.increment("T.#{node.name}")
+          end
+
+          super
+        end
+
+        private
+
+        #: (Prism::ClassNode | Prism::ModuleNode | Prism::SingletonClassNode) { -> void } -> void
+        def visit_scope(node, &block)
+          key = node_key(node)
+          @counters.increment(key)
+          @counters.increment("#{key}_with_rbs_type_params") if node_rbs_comments(node).signatures.any?
+
+          old_type_params = @type_params
+          @type_params = []
+
+          yield
+
+          @counters.increment("#{key}_with_srb_type_params") if @type_params.any?
+
+          @type_params = old_type_params
+        end
+
+        #: (Prism::CallNode) -> void
+        def visit_attr_accessor(node)
+          @counters.increment("accessors")
+
+          rbs_sigs = node_rbs_comments(node).signatures
+          srb_sigs = collect_last_srb_sigs
+
+          if rbs_sigs.any?
+            @counters.increment("accessors_with_rbs_sig")
+          end
+
+          if srb_sigs.any?
+            @counters.increment("accessors_with_srb_sig")
+          end
+
+          if rbs_sigs.empty? && srb_sigs.empty?
+            @counters.increment("accessors_without_sig")
+          end
+        end
+
+        #: (Prism::CallNode) -> void
+        def visit_sig(node)
+          @last_sigs << node
+          @counters.increment("srb_sigs")
+
+          if node.slice =~ /abstract/
+            @counters.increment("srb_sigs_abstract")
+          end
+        end
+
+        #: (Prism::CallNode) -> void
+        def visit_type_member(node)
+          key = case node.name
+          when :type_member
+            "type_members"
+          when :type_template
+            "type_templates"
+          else
+            return
+          end
+
+          @counters.increment(key)
+
+          @type_params << node
+        end
+
+        #: -> Array[Prism::CallNode]
+        def collect_last_srb_sigs
+          sigs = @last_sigs.dup
+          @last_sigs.clear
+          sigs
+        end
+
+        #: (Prism::ClassNode | Prism::ModuleNode | Prism::SingletonClassNode) -> String
+        def node_key(node)
+          case node
+          when Prism::ClassNode
+            "classes"
+          when Prism::ModuleNode
+            "modules"
+          when Prism::SingletonClassNode
+            "singleton_classes"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/spoom/sorbet/metrics/metrics_file_parser.rb

@@ -0,0 +1,34 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "spoom/sorbet/sigils"
+
+module Spoom
+  module Sorbet
+    module Metrics
+      module MetricsFileParser
+        DEFAULT_PREFIX = "ruby_typer.unknown."
+
+        class << self
+          #: (String path, ?String prefix) -> Hash[String, Integer]
+          def parse_file(path, prefix = DEFAULT_PREFIX)
+            parse_string(File.read(path), prefix)
+          end
+
+          #: (String string, ?String prefix) -> Hash[String, Integer]
+          def parse_string(string, prefix = DEFAULT_PREFIX)
+            parse_hash(JSON.parse(string), prefix)
+          end
+
+          #: (Hash[String, untyped] obj, ?String prefix) -> Counters
+          def parse_hash(obj, prefix = DEFAULT_PREFIX)
+            obj["metrics"].each_with_object(Counters.new) do |metric, metrics|
+              name = metric["name"].sub(prefix, "")
+              metrics[name] = metric["value"] || 0
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/spoom/sorbet/metrics.rb

@@ -1,35 +1,5 @@
 # typed: strict
 # frozen_string_literal: true
 
-require_relative "sigils"
-
-module Spoom
-  module Sorbet
-    module MetricsParser
-      DEFAULT_PREFIX = "ruby_typer.unknown."
-
-      class << self
-        extend T::Sig
-
-        sig { params(path: String, prefix: String).returns(T::Hash[String, Integer]) }
-        def parse_file(path, prefix = DEFAULT_PREFIX)
-          parse_string(File.read(path), prefix)
-        end
-
-        sig { params(string: String, prefix: String).returns(T::Hash[String, Integer]) }
-        def parse_string(string, prefix = DEFAULT_PREFIX)
-          parse_hash(JSON.parse(string), prefix)
-        end
-
-        sig { params(obj: T::Hash[String, T.untyped], prefix: String).returns(T::Hash[String, Integer]) }
-        def parse_hash(obj, prefix = DEFAULT_PREFIX)
-          obj["metrics"].each_with_object(Hash.new(0)) do |metric, metrics|
-            name = metric["name"]
-            name = name.sub(prefix, "")
-            metrics[name] = metric["value"] || 0
-          end
-        end
-      end
-    end
-  end
-end
+require "spoom/sorbet/metrics/code_metrics_visitor"
+require "spoom/sorbet/metrics/metrics_file_parser"

data/lib/spoom/sorbet/sigils.rb

@@ -7,8 +7,6 @@
 module Spoom
   module Sorbet
     module Sigils
-      extend T::Sig
-
       STRICTNESS_IGNORE = "ignore"
       STRICTNESS_FALSE = "false"
       STRICTNESS_TRUE = "true"
@@ -16,50 +14,45 @@ module Spoom
       STRICTNESS_STRONG = "strong"
       STRICTNESS_INTERNAL = "__STDLIB_INTERNAL"
 
-      VALID_STRICTNESS = T.let(
-        [
-          STRICTNESS_IGNORE,
-          STRICTNESS_FALSE,
-          STRICTNESS_TRUE,
-          STRICTNESS_STRICT,
-          STRICTNESS_STRONG,
-          STRICTNESS_INTERNAL,
-        ].freeze,
-        T::Array[String],
-      )
+      VALID_STRICTNESS = [
+        STRICTNESS_IGNORE,
+        STRICTNESS_FALSE,
+        STRICTNESS_TRUE,
+        STRICTNESS_STRICT,
+        STRICTNESS_STRONG,
+        STRICTNESS_INTERNAL,
+      ].freeze #: Array[String]
 
-      SIGIL_REGEXP = T.let(/^#[[:blank:]]*typed:[[:blank:]]*(\S*)/, Regexp)
+      SIGIL_REGEXP = /^#[[:blank:]]*typed:[[:blank:]]*(\S*)/ #: Regexp
 
       class << self
-        extend T::Sig
-
         # returns the full sigil comment string for the passed strictness
-        sig { params(strictness: String).returns(String) }
+        #: (String strictness) -> String
         def sigil_string(strictness)
           "# typed: #{strictness}"
         end
 
         # returns true if the passed string is a valid strictness (else false)
-        sig { params(strictness: String).returns(T::Boolean) }
+        #: (String strictness) -> bool
         def valid_strictness?(strictness)
           VALID_STRICTNESS.include?(strictness.strip)
         end
 
         # returns the strictness of a sigil in the passed file content string (nil if no sigil)
-        sig { params(content: String).returns(T.nilable(String)) }
+        #: (String content) -> String?
         def strictness_in_content(content)
           SIGIL_REGEXP.match(content)&.[](1)
         end
 
         # returns a string which is the passed content but with the sigil updated to a new strictness
-        sig { params(content: String, new_strictness: String).returns(String) }
+        #: (String content, String new_strictness) -> String
         def update_sigil(content, new_strictness)
           content.sub(SIGIL_REGEXP, sigil_string(new_strictness))
         end
 
         # returns a string containing the strictness of a sigil in a file at the passed path
         # * returns nil if no sigil
-        sig { params(path: T.any(String, Pathname)).returns(T.nilable(String)) }
+        #: ((String | Pathname) path) -> String?
         def file_strictness(path)
           return unless File.file?(path)
 
@@ -68,7 +61,7 @@ module Spoom
         end
 
         # changes the sigil in the file at the passed path to the specified new strictness
-        sig { params(path: T.any(String, Pathname), new_strictness: String).returns(T::Boolean) }
+        #: ((String | Pathname) path, String new_strictness) -> bool
         def change_sigil_in_file(path, new_strictness)
           content = File.read(path, encoding: Encoding::ASCII_8BIT)
           new_content = update_sigil(content, new_strictness)
@@ -79,7 +72,7 @@ module Spoom
         end
 
         # changes the sigil to have a new strictness in a list of files
-        sig { params(path_list: T::Array[String], new_strictness: String).returns(T::Array[String]) }
+        #: (Array[String] path_list, String new_strictness) -> Array[String]
         def change_sigil_in_files(path_list, new_strictness)
           path_list.filter do |path|
             change_sigil_in_file(path, new_strictness)

data/lib/spoom/sorbet/translate/rbs_comments_to_sorbet_sigs.rb

@@ -0,0 +1,242 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  module Sorbet
+    module Translate
+      class RBSCommentsToSorbetSigs < Translator
+        include Spoom::RBS::ExtractRBSComments
+
+        # @override
+        #: (Prism::ClassNode node) -> void
+        def visit_class_node(node)
+          apply_class_annotations(node)
+
+          super
+        end
+
+        # @override
+        #: (Prism::ModuleNode node) -> void
+        def visit_module_node(node)
+          apply_class_annotations(node)
+
+          super
+        end
+
+        # @override
+        #: (Prism::SingletonClassNode node) -> void
+        def visit_singleton_class_node(node)
+          apply_class_annotations(node)
+
+          super
+        end
+
+        # @override
+        #: (Prism::DefNode node) -> void
+        def visit_def_node(node)
+          comments = node_rbs_comments(node)
+          return if comments.empty?
+
+          return if comments.signatures.empty?
+
+          builder = RBI::Parser::TreeBuilder.new(@ruby_contents, comments: [], file: @file)
+          builder.visit(node)
+          rbi_node = builder.tree.nodes.first #: as RBI::Method
+
+          comments.signatures.each do |signature|
+            method_type = ::RBS::Parser.parse_method_type(signature.string)
+            translator = RBI::RBS::MethodTypeTranslator.new(rbi_node)
+            translator.visit(method_type)
+            sig = translator.result
+            apply_member_annotations(comments.annotations, sig)
+
+            @rewriter << Source::Replace.new(
+              signature.location.start_offset,
+              signature.location.end_offset,
+              sig.string,
+            )
+          rescue ::RBS::ParsingError
+            # Ignore signatures with errors
+            next
+          end
+        end
+
+        # @override
+        #: (Prism::CallNode node) -> void
+        def visit_call_node(node)
+          case node.message
+          when "attr_reader", "attr_writer", "attr_accessor"
+            visit_attr(node)
+          else
+            super
+          end
+        end
+
+        private
+
+        #: (Prism::CallNode) -> void
+        def visit_attr(node)
+          comments = node_rbs_comments(node)
+          return if comments.empty?
+
+          return if comments.signatures.empty?
+
+          comments.signatures.each do |signature|
+            attr_type = ::RBS::Parser.parse_type(signature.string)
+            sig = RBI::Sig.new
+
+            if node.message == "attr_writer"
+              if node.arguments&.arguments&.size != 1
+                raise Error, "AttrWriter must have exactly one name"
+              end
+
+              name = node.arguments&.arguments&.first #: as Prism::SymbolNode
+              sig.params << RBI::SigParam.new(
+                name.slice[1..-1], #: as String
+                RBI::RBS::TypeTranslator.translate(attr_type),
+              )
+            end
+
+            sig.return_type = RBI::RBS::TypeTranslator.translate(attr_type)
+
+            apply_member_annotations(comments.annotations, sig)
+
+            @rewriter << Source::Replace.new(
+              signature.location.start_offset,
+              signature.location.end_offset,
+              sig.string,
+            )
+          end
+        end
+
+        #: (Prism::ClassNode | Prism::ModuleNode | Prism::SingletonClassNode) -> void
+        def apply_class_annotations(node)
+          comments = node_rbs_comments(node)
+          return if comments.empty?
+
+          indent = " " * (node.location.start_column + 2)
+          insert_pos = case node
+          when Prism::ClassNode
+            (node.superclass || node.constant_path).location.end_offset
+          when Prism::ModuleNode
+            node.constant_path.location.end_offset
+          when Prism::SingletonClassNode
+            node.expression.location.end_offset
+          end
+
+          if comments.annotations.any?
+            unless already_extends?(node, /^(::)?T::Helpers$/)
+              @rewriter << Source::Insert.new(insert_pos, "\n#{indent}extend T::Helpers\n")
+            end
+
+            comments.annotations.reverse_each do |annotation|
+              from = adjust_to_line_start(annotation.location.start_offset)
+              to = adjust_to_line_end(annotation.location.end_offset)
+
+              content = case annotation.string
+              when "@abstract"
+                "abstract!"
+              when "@interface"
+                "interface!"
+              when "@sealed"
+                "sealed!"
+              when "@final"
+                "final!"
+              when /^@requires_ancestor: /
+                srb_type = ::RBS::Parser.parse_type(annotation.string.delete_prefix("@requires_ancestor: "))
+                rbs_type = RBI::RBS::TypeTranslator.translate(srb_type)
+                "requires_ancestor { #{rbs_type} }"
+              else
+                next
+              end
+
+              @rewriter << Source::Delete.new(from, to)
+
+              newline = node.body.nil? ? "" : "\n"
+              @rewriter << Source::Insert.new(insert_pos, "\n#{indent}#{content}#{newline}")
+            end
+          end
+
+          signatures = comments.signatures
+          if signatures.any?
+            signatures.each do |signature|
+              type_params = ::RBS::Parser.parse_type_params(signature.string)
+              next if type_params.empty?
+
+              from = adjust_to_line_start(signature.location.start_offset)
+              to = adjust_to_line_end(signature.location.end_offset)
+              @rewriter << Source::Delete.new(from, to)
+
+              unless already_extends?(node, /^(::)?T::Generic$/)
+                @rewriter << Source::Insert.new(insert_pos, "\n#{indent}extend T::Generic\n")
+              end
+
+              type_params.each do |type_param|
+                type_member = "#{type_param.name} = type_member"
+
+                case type_param.variance
+                when :covariant
+                  type_member = "#{type_member}(:out)"
+                when :contravariant
+                  type_member = "#{type_member}(:in)"
+                end
+
+                if type_param.upper_bound || type_param.default_type
+                  if type_param.upper_bound
+                    rbs_type = RBI::RBS::TypeTranslator.translate(type_param.upper_bound)
+                    type_member = "#{type_member} {{ upper: #{rbs_type} }}"
+                  end
+
+                  if type_param.default_type
+                    rbs_type = RBI::RBS::TypeTranslator.translate(type_param.default_type)
+                    type_member = "#{type_member} {{ fixed: #{rbs_type} }}"
+                  end
+                end
+
+                newline = node.body.nil? ? "" : "\n"
+                @rewriter << Source::Insert.new(insert_pos, "\n#{indent}#{type_member}#{newline}")
+              end
+            end
+          end
+        end
+
+        #: (Array[RBS::Annotations], RBI::Sig) -> void
+        def apply_member_annotations(annotations, sig)
+          annotations.each do |annotation|
+            case annotation.string
+            when "@abstract"
+              sig.is_abstract = true
+            when "@final"
+              sig.is_final = true
+            when "@override"
+              sig.is_override = true
+            when "@override(allow_incompatible: true)"
+              sig.is_override = true
+              sig.allow_incompatible_override = true
+            when "@overridable"
+              sig.is_overridable = true
+            when "@without_runtime"
+              sig.without_runtime = true
+            end
+          end
+        end
+
+        #: (Prism::ClassNode | Prism::ModuleNode | Prism::SingletonClassNode, Regexp) -> bool
+        def already_extends?(node, constant_regex)
+          node.child_nodes.any? do |c|
+            next false unless c.is_a?(Prism::CallNode)
+            next false unless c.message == "extend"
+            next false unless c.receiver.nil? || c.receiver.is_a?(Prism::SelfNode)
+            next false unless c.arguments&.arguments&.size == 1
+
+            arg = c.arguments&.arguments&.first
+            next false unless arg.is_a?(Prism::ConstantPathNode)
+            next false unless arg.slice.match?(constant_regex)
+
+            true
+          end
+        end
+      end
+    end
+  end
+end