spoom 1.6.3 → 1.7.0

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

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

@@ -0,0 +1,23 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  module Sorbet
+    module Translate
+      # Deletes all `sig` nodes from the given Ruby code.
+      # It doesn't handle type members and class annotations.
+      class StripSorbetSigs < Translator
+        # @override
+        #: (Prism::CallNode node) -> void
+        def visit_call_node(node)
+          return unless sorbet_sig?(node)
+
+          @rewriter << Source::Delete.new(
+            adjust_to_line_start(node.location.start_offset),
+            adjust_to_line_end(node.location.end_offset),
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  module Sorbet
+    module Translate
+      # @abstract
+      class Translator < Spoom::Visitor
+        #: (String, file: String) -> void
+        def initialize(ruby_contents, file:)
+          super()
+
+          @file = file #: String
+
+          @original_encoding = ruby_contents.encoding #: Encoding
+          @ruby_contents = if @original_encoding == "UTF-8"
+            ruby_contents
+          else
+            ruby_contents.encode("UTF-8")
+          end #: String
+
+          node = Spoom.parse_ruby(ruby_contents, file: file, comments: true)
+          @node = node #: Prism::Node
+          @ruby_bytes = ruby_contents.bytes #: Array[Integer]
+          @rewriter = Spoom::Source::Rewriter.new #: Source::Rewriter
+        end
+
+        #: -> String
+        def rewrite
+          visit(@node)
+          @rewriter.rewrite!(@ruby_bytes)
+          @ruby_bytes.pack("C*").force_encoding(@original_encoding)
+        end
+
+        private
+
+        #: (Prism::CallNode node) -> bool
+        def sorbet_sig?(node)
+          return false unless node.message == "sig"
+
+          recv = node.receiver
+          return false if recv && !recv.is_a?(Prism::SelfNode) && !recv.slice.match?(/(::)?T::Sig::WithoutRuntime/)
+
+          true
+        end
+
+        #: (Integer) -> Integer
+        def adjust_to_line_start(offset)
+          offset -= 1 while offset > 0 && @ruby_bytes[offset - 1] != "\n".ord
+          offset
+        end
+
+        #: (Integer) -> Integer
+        def adjust_to_line_end(offset)
+          offset += 1 while offset < @ruby_bytes.size && @ruby_bytes[offset] != "\n".ord
+          offset
+        end
+
+        # Consume the next blank line if any
+        #: (Integer) -> Integer
+        def adjust_to_new_line(offset)
+          if offset + 1 < @ruby_bytes.size && @ruby_bytes[offset + 1] == "\n".ord
+            offset += 1
+          end
+
+          offset
+        end
+      end
+    end
+  end
+end

data/lib/spoom/sorbet/translate.rb

@@ -0,0 +1,49 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "rbi"
+
+require "spoom/source/rewriter"
+require "spoom/sorbet/translate/translator"
+require "spoom/sorbet/translate/rbs_comments_to_sorbet_sigs"
+require "spoom/sorbet/translate/sorbet_assertions_to_rbs_comments"
+require "spoom/sorbet/translate/sorbet_sigs_to_rbs_comments"
+require "spoom/sorbet/translate/strip_sorbet_sigs"
+
+module Spoom
+  module Sorbet
+    module Translate
+      class Error < Spoom::Error; end
+
+      class << self
+        # Deletes all `sig` nodes from the given Ruby code.
+        # It doesn't handle type members and class annotations.
+        #: (String ruby_contents, file: String) -> String
+        def strip_sorbet_sigs(ruby_contents, file:)
+          StripSorbetSigs.new(ruby_contents, file: file).rewrite
+        end
+
+        # Converts all `sig` nodes to RBS comments in the given Ruby code.
+        # It also handles type members and class annotations.
+        #: (String ruby_contents, file: String, ?positional_names: bool) -> String
+        def sorbet_sigs_to_rbs_comments(ruby_contents, file:, positional_names: true)
+          SorbetSigsToRBSComments.new(ruby_contents, file: file, positional_names: positional_names).rewrite
+        end
+
+        # Converts all the RBS comments in the given Ruby code to `sig` nodes.
+        # It also handles type members and class annotations.
+        #: (String ruby_contents, file: String) -> String
+        def rbs_comments_to_sorbet_sigs(ruby_contents, file:)
+          RBSCommentsToSorbetSigs.new(ruby_contents, file: file).rewrite
+        end
+
+        # Converts all `T.let` and `T.cast` nodes to RBS comments in the given Ruby code.
+        # It also handles type members and class annotations.
+        #: (String ruby_contents, file: String) -> String
+        def sorbet_assertions_to_rbs_comments(ruby_contents, file:)
+          SorbetAssertionsToRBSComments.new(ruby_contents, file: file).rewrite
+        end
+      end
+    end
+  end
+end

data/lib/spoom/sorbet.rb

@@ -1,12 +1,12 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "spoom/sorbet/assertions"
 require "spoom/sorbet/config"
 require "spoom/sorbet/errors"
 require "spoom/sorbet/lsp"
 require "spoom/sorbet/metrics"
 require "spoom/sorbet/sigils"
+require "spoom/sorbet/translate"
 
 require "open3"
 

data/lib/spoom/source/rewriter.rb

@@ -0,0 +1,167 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  # This module provides a simple API to rewrite source code.
+  #
+  # Using a `Rewriter`, you can build a list of changes to apply to a source file
+  # and apply them all at once. Edits are applied from bottom to top, so that the
+  # line numbers are not remapped after each edit.
+  #
+  # The source code is represented as an array of bytes, so that it can be
+  # manipulated in place. The client is responsible for `string <-> bytes`
+  # conversions and encoding handling.
+  #
+  # ```ruby
+  # bytes = "def foo; end".bytes
+  #
+  # rewriter = Spoom::Source::Rewriter.new
+  # rewriter << Spoom::Source::Replace.new(4, 6, "baz")
+  # rewriter << Spoom::Source::Insert.new(0, "def bar; end\n")
+  # rewriter.rewrite!(bytes)
+  #
+  # puts bytes.pack("C*") # => "def bar; end\ndef baz; end"
+  # ```
+  module Source
+    class PositionError < Spoom::Error; end
+
+    # @abstract
+    class Edit
+      # @abstract
+      #: (Array[Integer]) -> void
+      def apply(bytes); end
+
+      # @abstract
+      #: -> [Integer, Integer]
+      def range; end
+    end
+
+    class Insert < Edit
+      #: Integer
+      attr_reader :position
+
+      #: String
+      attr_reader :text
+
+      #: (Integer, String) -> void
+      def initialize(position, text)
+        super()
+
+        @position = position
+        @text = text
+      end
+
+      # @override
+      #: (Array[Integer]) -> void
+      def apply(bytes)
+        raise PositionError, "Position is out of bounds" if position < 0 || position > bytes.size
+
+        bytes #: untyped
+          .insert(position, *text.bytes)
+      end
+
+      # @override
+      #: -> [Integer, Integer]
+      def range
+        [position, position]
+      end
+
+      # @override
+      #: -> String
+      def to_s
+        "Insert `#{text}` at #{position}"
+      end
+    end
+
+    class Replace < Edit
+      #: Integer
+      attr_reader :from, :to
+
+      #: String
+      attr_reader :text
+
+      #: (Integer, Integer, String) -> void
+      def initialize(from, to, text)
+        super()
+
+        @from = from
+        @to = to
+        @text = text
+      end
+
+      # @override
+      #: (Array[Integer]) -> void
+      def apply(bytes)
+        raise PositionError, "Position is out of bounds" if from < 0 || to < 0 || from > bytes.size || to > bytes.size || from > to
+
+        bytes[from..to] = *text.bytes
+      end
+
+      # @override
+      #: -> [Integer, Integer]
+      def range
+        [from, to]
+      end
+
+      # @override
+      #: -> String
+      def to_s
+        "Replace #{from}-#{to} with `#{text}`"
+      end
+    end
+
+    class Delete < Edit
+      #: Integer
+      attr_reader :from, :to
+
+      #: (Integer, Integer) -> void
+      def initialize(from, to)
+        super()
+
+        @from = from
+        @to = to
+      end
+
+      # @override
+      #: (Array[untyped]) -> void
+      def apply(bytes)
+        raise PositionError, "Position is out of bounds" if from < 0 || to < 0 || from > bytes.size || to > bytes.size || from > to
+
+        bytes[from..to] = "".bytes
+      end
+
+      # @override
+      #: -> [Integer, Integer]
+      def range
+        [from, to]
+      end
+
+      # @override
+      #: -> String
+      def to_s
+        "Delete #{from}-#{to}"
+      end
+    end
+
+    class Rewriter
+      #: -> void
+      def initialize
+        @edits = [] #: Array[Edit]
+      end
+
+      #: (Edit) -> void
+      def <<(other)
+        @edits << other
+      end
+
+      #: (Array[Integer]) -> void
+      def rewrite!(bytes)
+        # To avoid remapping positions after each edit,
+        # we sort the changes by position and apply them in reverse order.
+        @edits.sort_by(&:range).reverse_each do |edit|
+          edit.apply(bytes)
+        end
+      end
+    end
+  end
+end

data/lib/spoom/source.rb

@@ -0,0 +1,4 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "source/rewriter"

data/lib/spoom/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Spoom
-  VERSION = "1.6.3"
+  VERSION = "1.7.0"
 end

data/lib/spoom.rb

@@ -15,7 +15,9 @@ require "spoom/context"
 require "spoom/colors"
 require "spoom/poset"
 require "spoom/model"
+require "spoom/source"
 require "spoom/deadcode"
+require "spoom/rbs"
 require "spoom/sorbet"
 require "spoom/cli"
 require "spoom/version"