spoom 1.6.3 → 1.7.1

data/lib/spoom/sorbet/metrics.rb

@@ -1,33 +1,5 @@
 # typed: strict
 # frozen_string_literal: true
 
-require_relative "sigils"
-
-module Spoom
-  module Sorbet
-    module MetricsParser
-      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) -> 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/translate/rbs_comments_to_sorbet_sigs.rb

@@ -0,0 +1,239 @@
+# 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)
+              @rewriter << Source::Delete.new(from, to)
+
+              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} }"
+              end
+
+              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

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

@@ -0,0 +1,123 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  module Sorbet
+    module Translate
+      # Translates Sorbet assertions to RBS comments.
+      class SorbetAssertionsToRBSComments < Translator
+        LINE_BREAK = "\n".ord #: Integer
+
+        # @override
+        #: (Prism::CallNode) -> void
+        def visit_call_node(node)
+          return super unless t_annotation?(node)
+          return super unless at_end_of_line?(node)
+
+          value = T.must(node.arguments&.arguments&.first)
+          rbs_annotation = build_rbs_annotation(node)
+
+          start_offset = node.location.start_offset
+          end_offset = node.location.end_offset
+          @rewriter << Source::Replace.new(start_offset, end_offset - 1, "#{dedent_value(node, value)} #{rbs_annotation}")
+        end
+
+        private
+
+        #: (Prism::CallNode) -> void
+        def build_rbs_annotation(call)
+          case call.name
+          when :let
+            srb_type = call.arguments&.arguments&.last #: as !nil
+            rbs_type = RBI::Type.parse_node(srb_type).rbs_string
+            "#: #{rbs_type}"
+          when :cast
+            srb_type = call.arguments&.arguments&.last #: as !nil
+            rbs_type = RBI::Type.parse_node(srb_type).rbs_string
+            "#: as #{rbs_type}"
+          when :must
+            "#: as !nil"
+          when :unsafe
+            "#: as untyped"
+          else
+            raise "Unknown annotation method: #{call.name}"
+          end
+        end
+
+        # Is this node a `T` or `::T` constant?
+        #: (Prism::Node?) -> bool
+        def t?(node)
+          case node
+          when Prism::ConstantReadNode
+            node.name == :T
+          when Prism::ConstantPathNode
+            node.parent.nil? && node.name == :T
+          else
+            false
+          end
+        end
+
+        # Is this node a `T.let` or `T.cast`?
+        #: (Prism::CallNode) -> bool
+        def t_annotation?(node)
+          return false unless t?(node.receiver)
+
+          case node.name
+          when :let, :cast
+            return node.arguments&.arguments&.size == 2
+          when :must, :unsafe
+            return node.arguments&.arguments&.size == 1
+          end
+
+          false
+        end
+
+        #: (Prism::Node) -> bool
+        def at_end_of_line?(node)
+          end_offset = node.location.end_offset
+          end_offset += 1 while (@ruby_bytes[end_offset] == " ".ord) && (end_offset < @ruby_bytes.size)
+          @ruby_bytes[end_offset] == LINE_BREAK
+        end
+
+        #: (Prism::Node, Prism::Node) -> String
+        def dedent_value(assign, value)
+          if value.location.start_line == assign.location.start_line
+            # The value is on the same line as the assign, so we can just return the slice as is:
+            # ```rb
+            # a = T.let(nil, T.nilable(String))
+            # ```
+            # becomes
+            # ```rb
+            # a = nil #: String?
+            # ```
+            return value.slice
+          end
+
+          # The value is on a different line, so we need to dedent it:
+          # ```rb
+          # a = T.let(
+          #   [
+          #     1, 2, 3,
+          #   ],
+          #   T::Array[Integer],
+          # )
+          # ```
+          # becomes
+          # ```rb
+          # a = [
+          #   1, 2, 3,
+          # ] #: Array[Integer]
+          # ```
+          indent = value.location.start_line - assign.location.start_line
+          lines = value.slice.lines
+          if lines.size > 1
+            lines[1..]&.each_with_index do |line, i|
+              lines[i + 1] = line.delete_prefix("  " * indent)
+            end
+          end
+          lines.join
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,293 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  module Sorbet
+    module Translate
+      # Converts all `sig` nodes to RBS comments in the given Ruby code.
+      # It also handles type members and class annotations.
+      class SorbetSigsToRBSComments < Translator
+        #: (String, file: String, positional_names: bool) -> void
+        def initialize(ruby_contents, file:, positional_names:)
+          super(ruby_contents, file: file)
+
+          @positional_names = positional_names #: bool
+          @nesting = [] #: Array[Prism::ClassNode | Prism::ModuleNode | Prism::SingletonClassNode]
+          @last_sigs = [] #: Array[[Prism::CallNode, RBI::Sig]]
+          @type_members = [] #: Array[String]
+        end
+
+        # @override
+        #: (Prism::ClassNode) -> void
+        def visit_class_node(node)
+          visit_scope(node) { super }
+        end
+
+        # @override
+        #: (Prism::ModuleNode) -> void
+        def visit_module_node(node)
+          visit_scope(node) { super }
+        end
+
+        # @override
+        #: (Prism::SingletonClassNode) -> void
+        def visit_singleton_class_node(node)
+          visit_scope(node) { super }
+        end
+
+        # @override
+        #: (Prism::DefNode) -> void
+        def visit_def_node(node)
+          return if @last_sigs.empty?
+          return if @last_sigs.any? { |_, sig| sig.is_abstract }
+
+          apply_member_annotations(@last_sigs)
+
+          # Build the RBI::Method node so we can print the method signature as RBS.
+          builder = RBI::Parser::TreeBuilder.new(@ruby_contents, comments: [], file: @file)
+          builder.visit(node)
+          rbi_node = builder.tree.nodes.first #: as RBI::Method
+
+          @last_sigs.each do |node, sig|
+            out = StringIO.new
+            p = RBI::RBSPrinter.new(out: out, indent: node.location.start_column, positional_names: @positional_names)
+            p.print("#: ")
+            p.send(:print_method_sig, rbi_node, sig)
+            p.print("\n")
+            @rewriter << Source::Replace.new(node.location.start_offset, node.location.end_offset, out.string)
+          end
+
+          @last_sigs.clear
+        end
+
+        # @override
+        #: (Prism::CallNode) -> void
+        def visit_call_node(node)
+          case node.message
+          when "sig"
+            visit_sig(node)
+          when "attr_reader", "attr_writer", "attr_accessor"
+            visit_attr(node)
+          when "extend"
+            visit_extend(node)
+          when "abstract!", "interface!", "sealed!", "final!", "requires_ancestor"
+            visit_class_annotation(node)
+          else
+            super
+          end
+        end
+
+        # @override
+        #: (Prism::ConstantWriteNode) -> void
+        def visit_constant_write_node(node)
+          call = node.value
+          return super unless call.is_a?(Prism::CallNode)
+          return super unless call.message == "type_member"
+
+          @type_members << build_type_member_string(node)
+
+          from = adjust_to_line_start(node.location.start_offset)
+          to = adjust_to_line_end(node.location.end_offset)
+          to = adjust_to_new_line(to)
+
+          @rewriter << Source::Delete.new(from, to)
+        end
+
+        private
+
+        #: (Prism::ClassNode | Prism::ModuleNode | Prism::SingletonClassNode) { -> void } -> void
+        def visit_scope(node, &block)
+          @nesting << node
+          old_type_members = @type_members
+          @type_members = []
+
+          yield
+
+          if @type_members.any?
+            indent = " " * node.location.start_column
+            @rewriter << Source::Insert.new(node.location.start_offset, "#: [#{@type_members.join(", ")}]\n#{indent}")
+          end
+
+          @type_members = old_type_members
+          @nesting.pop
+        end
+
+        #: (Prism::CallNode) -> void
+        def visit_sig(node)
+          return unless sorbet_sig?(node)
+
+          builder = RBI::Parser::SigBuilder.new(@ruby_contents, file: @file)
+          builder.current.loc = node.location
+          builder.visit_call_node(node)
+          builder.current.comments = []
+
+          @last_sigs << [node, builder.current]
+        end
+
+        #: (Prism::CallNode) -> void
+        def visit_attr(node)
+          unless node.message == "attr_reader" || node.message == "attr_writer" || node.message == "attr_accessor"
+            raise Error, "Expected attr_reader, attr_writer, or attr_accessor"
+          end
+
+          return if @last_sigs.empty?
+          return if @last_sigs.any? { |_, sig| sig.is_abstract }
+
+          apply_member_annotations(@last_sigs)
+
+          builder = RBI::Parser::TreeBuilder.new(@ruby_contents, comments: [], file: @file)
+          builder.visit(node)
+          rbi_node = builder.tree.nodes.first #: as RBI::Attr
+
+          @last_sigs.each do |node, sig|
+            out = StringIO.new
+            p = RBI::RBSPrinter.new(out: out, indent: node.location.start_column, positional_names: @positional_names)
+            p.print("#: ")
+            p.print_attr_sig(rbi_node, sig)
+            p.print("\n")
+            @rewriter << Source::Replace.new(node.location.start_offset, node.location.end_offset, out.string)
+          end
+
+          @last_sigs.clear
+        end
+
+        #: (Prism::CallNode node) -> void
+        def visit_extend(node)
+          raise Error, "Expected extend" unless node.message == "extend"
+
+          return unless node.receiver.nil? || node.receiver.is_a?(Prism::SelfNode)
+          return unless node.arguments&.arguments&.size == 1
+
+          arg = node.arguments&.arguments&.first
+          return unless arg.is_a?(Prism::ConstantPathNode)
+          return unless arg.slice.match?(/^(::)?T::Helpers$/) || arg.slice.match?(/^(::)?T::Generic$/)
+
+          from = adjust_to_line_start(node.location.start_offset)
+          to = adjust_to_line_end(node.location.end_offset)
+          to = adjust_to_new_line(to)
+          @rewriter << Source::Delete.new(from, to)
+        end
+
+        #: (Prism::CallNode node) -> void
+        def visit_class_annotation(node)
+          unless node.message == "abstract!" || node.message == "interface!" || node.message == "sealed!" ||
+              node.message == "final!" || node.message == "requires_ancestor"
+            raise Error, "Expected abstract!, interface!, sealed!, final!, or requires_ancestor"
+          end
+
+          return unless node.receiver.nil? || node.receiver.is_a?(Prism::SelfNode)
+          return unless node.arguments.nil?
+
+          klass = @nesting.last #: as Prism::Node
+          indent = " " * klass.location.start_column
+
+          case node.message
+          when "abstract!"
+            @rewriter << Source::Insert.new(klass.location.start_offset, "# @abstract\n#{indent}")
+          when "interface!"
+            @rewriter << Source::Insert.new(klass.location.start_offset, "# @interface\n#{indent}")
+          when "sealed!"
+            @rewriter << Source::Insert.new(klass.location.start_offset, "# @sealed\n#{indent}")
+          when "final!"
+            @rewriter << Source::Insert.new(klass.location.start_offset, "# @final\n#{indent}")
+          when "requires_ancestor"
+            block = node.block
+            return unless block.is_a?(Prism::BlockNode)
+
+            body = block.body
+            return unless body.is_a?(Prism::StatementsNode)
+            return unless body.body.size == 1
+
+            arg = body.body.first #: as Prism::Node
+            srb_type = RBI::Type.parse_node(arg)
+            @rewriter << Source::Insert.new(klass.location.start_offset, "# @requires_ancestor: #{srb_type.rbs_string}\n#{indent}")
+          end
+
+          from = adjust_to_line_start(node.location.start_offset)
+          to = adjust_to_line_end(node.location.end_offset)
+          to = adjust_to_new_line(to)
+
+          @rewriter << Source::Delete.new(from, to)
+        end
+
+        #: (Array[[Prism::CallNode, RBI::Sig]]) -> void
+        def apply_member_annotations(sigs)
+          return if sigs.empty?
+
+          node, _sig = sigs.first #: as [Prism::CallNode, RBI::Sig]
+          insert_pos = node.location.start_offset
+
+          if sigs.any? { |_, sig| sig.without_runtime }
+            @rewriter << Source::Insert.new(insert_pos, "# @without_runtime\n")
+          end
+
+          if sigs.any? { |_, sig| sig.is_final }
+            @rewriter << Source::Insert.new(insert_pos, "# @final\n")
+          end
+
+          if sigs.any? { |_, sig| sig.is_abstract }
+            @rewriter << Source::Insert.new(insert_pos, "# @abstract\n")
+          end
+
+          if sigs.any? { |_, sig| sig.is_override }
+            @rewriter << if sigs.any? { |_, sig| sig.allow_incompatible_override }
+              Source::Insert.new(insert_pos, "# @override(allow_incompatible: true)\n")
+            else
+              Source::Insert.new(insert_pos, "# @override\n")
+            end
+          end
+
+          if sigs.any? { |_, sig| sig.is_overridable }
+            @rewriter << Source::Insert.new(insert_pos, "# @overridable\n")
+          end
+        end
+
+        #: (Prism::ConstantWriteNode) -> String
+        def build_type_member_string(node)
+          call = node.value
+          raise Error, "Expected a call node" unless call.is_a?(Prism::CallNode)
+          raise Error, "Expected type_member" unless call.message == "type_member"
+
+          type_member = node.name.to_s
+
+          arg = call.arguments&.arguments&.first
+          if arg.is_a?(Prism::SymbolNode)
+            case arg.slice
+            when ":in"
+              type_member = "in #{type_member}"
+            when ":out"
+              type_member = "out #{type_member}"
+            else
+              raise Error, "Unknown type member variance: #{arg.slice}"
+            end
+          end
+
+          block = call.block
+          return type_member unless block.is_a?(Prism::BlockNode)
+
+          body = block.body
+          return type_member unless body.is_a?(Prism::StatementsNode)
+          return type_member unless body.body.size == 1
+
+          hash = body.body.first
+          return type_member unless hash.is_a?(Prism::HashNode)
+
+          hash.elements.each do |element|
+            next unless element.is_a?(Prism::AssocNode)
+
+            type = RBI::Type.parse_node(element.value)
+
+            case element.key.slice
+            when "upper:"
+              type_member = "#{type_member} < #{type.rbs_string}"
+            when "fixed:"
+              type_member = "#{type_member} = #{type.rbs_string}"
+            end
+          end
+
+          type_member
+        end
+      end
+    end
+  end
+end