ryac 0.2.0

data/lib/ryac/pipeline/file_collector.rb

@@ -0,0 +1,360 @@
+# frozen_string_literal: true
+
+require 'prism'
+
+module Ryac
+  module Pipeline
+    # Stage 1: File Collection
+    # Discovers all dependencies via static analysis of require/require_relative/autoload
+    class FileCollector
+      # @param entry_path [String, Array<String>] Path(s) to entry point file(s)
+      # @return [DependencyGraph] Graph of all discovered files
+      # @raise [FileNotFoundError] If a required file doesn't exist
+      # @raise [NoFilesError] If entry_path is nil or empty
+      # @raise [DynamicRequireError] If a dynamic require is detected
+      def call(entry_path, project_root: nil, gem_names: [], gem_require_paths: [])
+        raise NoFilesError.new if entry_path.nil?
+
+        entry_paths = Array(entry_path) #: Array[String]
+        raise NoFilesError.new if entry_paths.empty?
+
+        @graph = DependencyGraph.new
+        @visited = Set.new
+        @gem_names = gem_names
+        @project_roots = if project_root
+          # Array() leaves only Strings whichever of the two shapes came in
+          Array(project_root).map { |p| File.expand_path(p) } # steep:ignore ArgumentTypeMismatch
+        else
+          root = find_project_root(entry_paths)
+          root ? [root] : []
+        end
+
+        ensure_load_paths(gem_require_paths)
+
+        entry_paths.each do |path|
+          expanded = File.expand_path(path)
+          raise FileNotFoundError.new(expanded) unless File.exist?(expanded)
+          collect_file(expanded)
+        end
+
+        collect_rbs_files(entry_paths)
+        @graph
+      end
+
+      private
+
+      # Recursively collect a file and its dependencies
+      def collect_file(file_path, required_from: nil, line: nil)
+        return if @visited.include?(file_path)
+
+        unless File.exist?(file_path)
+          raise FileNotFoundError.new(file_path, required_from: required_from, line: line)
+        end
+
+        @visited.add(file_path)
+        # Ruby source defaults to UTF-8; reading with the ambient locale instead
+        # tags non-ASCII sources US-ASCII under a POSIX locale and every later
+        # String operation raises on the invalid bytes.
+        content = File.read(file_path, encoding: Encoding::UTF_8)
+
+        # Parse and extract require statements
+        require_nodes = extract_require_nodes(file_path, content)
+        dependencies = [] #: Array[String]
+        in_class_dependencies = [] #: Array[String]
+
+        require_nodes.each do |node_info|
+          dep_path = node_info[:resolved_path]
+          next unless dep_path
+
+          if node_info[:in_class]
+            in_class_dependencies << dep_path
+          else
+            dependencies << dep_path
+          end
+          collect_file(dep_path, required_from: file_path, line: node_info[:line])
+        end
+
+        entry = FileEntry.new(
+          path: file_path,
+          content: content,
+          dependencies: dependencies,
+          in_class_dependencies: in_class_dependencies,
+          require_nodes: require_nodes
+        )
+
+        @graph.add_file(entry)
+      end
+
+      # Extract require/require_relative/autoload nodes from source
+      def extract_require_nodes(file_path, content)
+        result = Prism.parse(content)
+        # Collection is the only point that still knows which file a byte
+        # came from — a syntax error surfaces here with real coordinates,
+        # or downstream as a nameless internal failure.
+        error = result.errors[0]
+        if error
+          raise Ryac::SyntaxError.new(error.message, path: file_path,
+                                      line: error.location.start_line,
+                                      column: error.location.start_column)
+        end
+        nodes = [] #: Array[require_node_info]
+
+        traverse_for_requires(result.value, nodes, file_path)
+
+        nodes
+      end
+
+      # Traverse AST to find require statements
+      # @param in_method [Boolean] true when inside a DefNode body; dynamic requires are skipped
+      def traverse_for_requires(node, nodes, file_path, in_method: false, in_class: false)
+        return unless node
+
+        case node
+        when Prism::CallNode
+          handle_call_node(node, nodes, file_path, in_method: in_method, in_class: in_class)
+        when Prism::ProgramNode
+          traverse_for_requires(node.statements, nodes, file_path, in_method: in_method, in_class: in_class)
+        when Prism::StatementsNode
+          node.body.each { |child| traverse_for_requires(child, nodes, file_path, in_method: in_method, in_class: in_class) }
+        when Prism::ClassNode, Prism::ModuleNode
+          traverse_for_requires(node.body, nodes, file_path, in_method: in_method, in_class: true)
+        when Prism::DefNode
+          traverse_for_requires(node.body, nodes, file_path, in_method: true, in_class: in_class)
+        when Prism::IfNode
+          traverse_for_requires(node.statements, nodes, file_path, in_method: in_method, in_class: in_class)
+          traverse_for_requires(node.subsequent, nodes, file_path, in_method: in_method, in_class: in_class)
+        when Prism::BeginNode
+          traverse_for_requires(node.statements, nodes, file_path, in_method: in_method, in_class: in_class)
+        end
+      end
+
+      def handle_call_node(node, nodes, file_path, in_method: false, in_class: false)
+        method_name = node.name
+
+        case method_name
+        when :require_relative
+          handle_require_relative(node, nodes, file_path, in_method: in_method, in_class: in_class)
+        when :require
+          handle_require(node, nodes, file_path, in_method: in_method, in_class: in_class)
+        when :autoload
+          handle_autoload(node, nodes, file_path, in_method: in_method, in_class: in_class)
+        end
+
+        # Continue traversing for nested calls
+        node.arguments&.arguments&.each do |arg|
+          traverse_for_requires(arg, nodes, file_path, in_method: in_method, in_class: in_class)
+        end
+        traverse_for_requires(node.block, nodes, file_path, in_method: in_method, in_class: in_class) if node.block
+      end
+
+      def handle_require_relative(node, nodes, file_path, in_method: false, in_class: false)
+        arg = node.arguments&.arguments&.first
+        return unless arg
+
+        if arg.is_a?(Prism::StringNode)
+          nodes << {
+            type: :require_relative,
+            path: arg.unescaped,
+            line: node.location.start_line,
+            start_offset: node.location.start_offset,
+            length: node.location.length,
+            in_class: in_class,
+            in_method: in_method,
+            resolved_path: resolve_relative_path(arg.unescaped, file_path)
+          }
+        else
+          return if in_method
+
+          raise DynamicRequireError.new(
+            file_path,
+            line: node.location.start_line,
+            expression: node.slice
+          )
+        end
+      end
+
+      def handle_require(node, nodes, file_path, in_method: false, in_class: false)
+        arg = node.arguments&.arguments&.first
+        return unless arg
+
+        if arg.is_a?(Prism::StringNode)
+          path = arg.unescaped
+          if path.start_with?('./', '../')
+            nodes << {
+              type: :require,
+              path: path,
+              line: node.location.start_line,
+              start_offset: node.location.start_offset,
+              length: node.location.length,
+              in_class: in_class,
+              in_method: in_method,
+              resolved_path: resolve_relative_path(path, file_path)
+            }
+          elsif (resolved = resolve_bare_require(path))
+            nodes << {
+              type: :require,
+              path: path,
+              line: node.location.start_line,
+              start_offset: node.location.start_offset,
+              length: node.location.length,
+              in_class: in_class,
+              in_method: in_method,
+              resolved_path: resolved
+            }
+          else
+            nodes << {
+              type: :require_stdlib,
+              path: path,
+              line: node.location.start_line,
+              start_offset: node.location.start_offset,
+              length: node.location.length,
+              in_class: in_class,
+              in_method: in_method
+            }
+          end
+        else
+          return if in_method
+
+          raise DynamicRequireError.new(
+            file_path,
+            line: node.location.start_line,
+            expression: node.slice
+          )
+        end
+      end
+
+      def handle_autoload(node, nodes, file_path, in_method: false, in_class: false)
+        args = node.arguments&.arguments
+        return unless args && args.size >= 2
+
+        path_arg = args[1]
+        path = if path_arg.is_a?(Prism::StringNode)
+          path_arg.unescaped
+        else
+          dir_interpolated_path(path_arg)
+        end
+
+        if path
+          # Treat autoload paths like require_relative for local files
+          if path.start_with?('./', '../') || !path.include?('/')
+            nodes << {
+              type: :autoload,
+              path: path,
+              line: node.location.start_line,
+              start_offset: node.location.start_offset,
+              length: node.location.length,
+              in_class: in_class,
+              in_method: in_method,
+              resolved_path: resolve_relative_path(path, file_path)
+            }
+          elsif (resolved = resolve_bare_require(path))
+            nodes << {
+              type: :autoload,
+              path: path,
+              line: node.location.start_line,
+              start_offset: node.location.start_offset,
+              length: node.location.length,
+              in_class: in_class,
+              in_method: in_method,
+              resolved_path: resolved
+            }
+          end
+        else
+          return if in_method
+
+          raise DynamicRequireError.new(
+            file_path,
+            line: node.location.start_line,
+            expression: node.slice
+          )
+        end
+      end
+
+      # "#{__dir__}/mixin/foo" reads as dynamic but is a constant at
+      # collection time: __dir__ is the directory of the file being
+      # collected. Recognizes exactly that shape — a sole receiverless,
+      # argument-less __dir__ interpolation, then a /-prefixed literal
+      # tail — and returns it as the file-relative "./mixin/foo" so the
+      # ordinary relative resolution runs; nil for every other
+      # interpolation.
+      def dir_interpolated_path(path_arg)
+        return nil unless path_arg.is_a?(Prism::InterpolatedStringNode)
+
+        parts = path_arg.parts
+        return nil unless parts.size == 2
+
+        interp, rest = parts
+        return nil unless interp.is_a?(Prism::EmbeddedStatementsNode) && rest.is_a?(Prism::StringNode)
+
+        call = AstUtils.unwrap_statements(interp.statements)
+        return nil unless call.is_a?(Prism::CallNode) &&
+                          call.name == :__dir__ && call.receiver.nil? && call.arguments.nil?
+
+        tail = rest.unescaped
+        tail.start_with?('/') ? ".#{tail}" : nil
+      end
+
+      def ensure_load_paths(require_paths)
+        require_paths.each do |path|
+          $LOAD_PATH.unshift(path) unless $LOAD_PATH.include?(path)
+        end
+      end
+
+      def collect_rbs_files(_entry_paths)
+        @project_roots.each do |root|
+          load_rbs_from(File.join(root, "sig"))
+        end
+
+        collect_rbs_stdlib_files
+      end
+
+      def collect_rbs_stdlib_files
+        return if @gem_names.empty?
+
+        stdlib_root = RBS::Repository::DEFAULT_STDLIB_ROOT
+
+        @gem_names.each do |gem_name|
+          gem_rbs_dir = File.join(stdlib_root, gem_name)
+          versions = Dir.children(gem_rbs_dir) rescue next
+          next if versions.empty?
+
+          latest = versions.max_by { |v| Gem::Version.new(v) } #: String
+          load_rbs_from(File.join(gem_rbs_dir, latest))
+        end
+      end
+
+      def load_rbs_from(dir)
+        Dir.glob(File.join(dir, "**", "*.rbs")).each do |path|
+          @graph.rbs_files[path] = File.read(path, encoding: Encoding::UTF_8)
+        end
+      end
+
+      def find_project_root(entry_paths)
+        dir = File.dirname(File.expand_path(entry_paths.first))
+        until dir == "/"
+          return dir if File.exist?(File.join(dir, "Gemfile")) || File.directory?(File.join(dir, ".git"))
+          dir = File.dirname(dir)
+        end
+        nil
+      end
+
+      def resolve_relative_path(path, from_file)
+        path += '.rb' unless path.end_with?('.rb')
+        File.expand_path(path, File.dirname(from_file))
+      end
+
+      # Resolve a bare require path (e.g., "foo") via $LOAD_PATH.
+      # Returns absolute path if the file is under any project root, nil otherwise.
+      def resolve_bare_require(path)
+        result = $LOAD_PATH.resolve_feature_path(path)
+        return nil unless result
+
+        type, abs_path = result
+        return nil unless type == :rb
+        return nil unless @project_roots.any? { |root| abs_path.start_with?("#{root}/") }
+
+        abs_path
+      end
+    end
+  end
+end

data/lib/ryac/pipeline/method_renamer.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module Ryac
+  module Pipeline
+    # Method renaming: renames method definitions and call sites.
+    class MethodRenamer < Stage
+      include RenamePatcher
+
+      def needs_analysis? = true
+
+      def collect(ctx, patches)
+        analysis = analysis(ctx)
+        rename_map = analysis.rename_map
+        method_alias_map = analysis.method_alias_map
+        @negated_transforms = {}
+        @source_bytes = analysis.source.content
+        collect_patches(ctx.ast, patches, analysis, rename_map, method_alias_map)
+      end
+
+      private
+
+      def collect_patches(node, patches, analysis, rename_map, method_alias_map)
+        # @type var callback: ^(Prism::Node) -> void
+        callback = proc { |subnode|
+          handle_node(subnode, patches, analysis, rename_map, method_alias_map)
+        }
+        walk_prism(node, &callback)
+      end
+
+      def handle_node(subnode, patches, analysis, rename_map, method_alias_map)
+        case subnode
+        when Prism::DefNode
+          patch_def_name(subnode, patches, rename_map)
+
+        when Prism::CallNode
+          patch_call_node(subnode, patches, rename_map, method_alias_map, analysis)
+
+        when Prism::CallOperatorWriteNode,
+             Prism::CallOrWriteNode,
+             Prism::CallAndWriteNode
+          patch_call_operator_write(subnode, patches, rename_map, method_alias_map)
+        end
+      end
+
+      def patch_def_name(node, patches, rename_map)
+        key = prism_location_key(node)
+        short = rename_map[key]
+        return unless short
+
+        name_loc = node.name_loc
+        patches << { start: name_loc.start_offset, end: name_loc.end_offset, replacement: short }
+      end
+
+      def patch_call_node(node, patches, rename_map, method_alias_map, analysis)
+        # Detect negated transforms: !receiver.empty? → receiver!=[]
+        # The ! CallNode is visited before its children, so we mark the inner
+        # node here and negate the transform when it's applied later.
+        if node.name == :"!" && node.receiver.is_a?(Prism::CallNode)
+          inner = node.receiver
+          inner_key = prism_location_key(inner)
+          transform = analysis.method_transform_map[inner_key]
+          if transform&.start_with?('==') && inner.call_operator_loc && !inner.safe_navigation?
+            @negated_transforms[inner_key] = true
+            patches << { start: node.location.start_offset, end: inner.location.start_offset, replacement: '' }
+          end
+        end
+
+        key = prism_location_key(node)
+
+        # Meta calls are structural, not plain calls: attr declarations are
+        # rewritten wholesale by AttrDeclShorten, and include must keep its
+        # name. Renaming or transforming them here would corrupt them.
+        return if analysis.meta_node_map[key]
+
+        # Structural transforms (e.g. .first → [0], .empty? → ==[])
+        transform = analysis.method_transform_map[key]
+        if transform && node.call_operator_loc && !node.safe_navigation?
+          replacement = @negated_transforms[key] ? "!#{transform[1..]}" : transform
+          end_offset = node.location.end_offset
+          # Consume trailing spaces around ternary ? when no longer needed
+          # e.g. .empty? ? "x" → ==[]?"x" since ] is not a name char
+          if @source_bytes.getbyte(end_offset) == 0x20 && @source_bytes.getbyte(end_offset + 1) == 0x3F # ' ' and '?'
+            end_offset += 2 # consume space + ternary ?
+            end_offset += 1 if @source_bytes.getbyte(end_offset) == 0x20 # consume space after ?
+            replacement = "#{replacement}?"
+          end
+          # call_operator_loc was checked at the top of this branch
+          patches << { start: node.call_operator_loc.start_offset, end: end_offset, replacement: replacement } # steep:ignore NoMethod
+          return
+        elsif transform && !node.call_operator_loc && node.receiver.is_a?(Prism::CallNode)
+          # A comparison-shape transform (.size==0 → ==[]), registered on
+          # the operator call whose receiver is the size query: the patch
+          # swallows the query and the comparison together.
+          receiver_end = node.receiver.receiver.location.end_offset # steep:ignore NoMethod
+          patches << { start: receiver_end, end: node.location.end_offset, replacement: transform }
+          return
+        end
+
+        return unless node.message_loc
+
+        short = rename_map[key]
+
+        # send/public_send/__send__: patch the symbol argument, not the method name
+        if short && SEND_METHODS.include?(node.name)
+          patch_send_symbol(node, patches, short)
+          return
+        end
+
+        alias_name = method_alias_map[key]&.to_s
+        replacement = short || alias_name
+        return unless replacement
+
+        if replacement.end_with?('=') && !replacement.end_with?('==') &&
+           node.name.to_s.end_with?('=') && !node.name.to_s.end_with?('==')
+          msg_slice = node.message_loc.slice
+          replacement = replacement.chomp('=') unless msg_slice.end_with?('=')
+        end
+
+        end_offset = node.message_loc.end_offset
+        # The compactor separates a ?/!-ending name from an =-starting
+        # operator with one protective space. A rename that drops the ?/!
+        # must take the space with it — left behind, re-minification removes
+        # it and the self-host fixed point drifts by a byte per site.
+        if node.name.to_s.end_with?('?', '!') && !replacement.end_with?('?', '!') &&
+           @source_bytes.getbyte(end_offset) == 0x20 && @source_bytes.getbyte(end_offset + 1) == 0x3D # ' ' then '='
+          end_offset += 1
+        end
+        patches << { start: node.message_loc.start_offset, end: end_offset, replacement: replacement }
+      end
+
+      SEND_METHODS = %i[send __send__ public_send].freeze
+
+      def patch_send_symbol(node, patches, short_name)
+        first_arg = node.arguments&.arguments&.first
+        return unless first_arg.is_a?(Prism::SymbolNode)
+
+        loc = first_arg.location
+        patches << { start: loc.start_offset, end: loc.end_offset, replacement: ":#{short_name}" }
+      end
+
+      def patch_call_operator_write(node, patches, rename_map, method_alias_map)
+        return unless node.message_loc
+        key = prism_location_key(node)
+        short = rename_map[key] || method_alias_map[key]&.to_s
+        return unless short
+        short = short.chomp('=') if short.end_with?('=') && !short.end_with?('==')
+        patches << { start: node.message_loc.start_offset, end: node.message_loc.end_offset, replacement: short }
+      end
+    end
+  end
+end

data/lib/ryac/pipeline/paren_optimizer.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module Ryac
+  module Pipeline
+    # Removes unnecessary parentheses from method calls at statement level.
+    # Operates as a source patcher: Prism.parse → walk AST → collect patches → apply.
+    # Only removes parens; never adds them.
+    class ParenOptimizer < Stage
+      def collect(ctx, patches)
+        walk(ctx.ast, ctx.source, patches, statement_level: true)
+      end
+
+      private
+
+      def walk(node, source, patches, statement_level:)
+        case node
+        when Prism::ProgramNode
+          walk(node.statements, source, patches, statement_level: true)
+
+        when Prism::StatementsNode
+          node.body.each { |child| walk(child, source, patches, statement_level: statement_level) }
+
+        when Prism::CallNode
+          try_remove_call_parens(node, source, patches) if statement_level
+          walk_call_children(node, source, patches)
+
+        when Prism::YieldNode
+          try_remove_yield_parens(node, patches) if statement_level
+          node.arguments&.arguments&.each { |arg| walk(arg, source, patches, statement_level: false) }
+
+        when Prism::IfNode
+          walk_if(node, source, patches)
+
+        when Prism::UnlessNode
+          walk(node.predicate, source, patches, statement_level: false)
+          walk(node.statements, source, patches, statement_level: true) if node.statements
+          walk(node.else_clause, source, patches, statement_level: true) if node.else_clause
+
+        when Prism::ElseNode
+          walk(node.statements, source, patches, statement_level: statement_level) if node.statements
+
+        when Prism::WhileNode, Prism::UntilNode
+          walk(node.predicate, source, patches, statement_level: false)
+          walk(node.statements, source, patches, statement_level: true) if node.statements
+
+        when Prism::ForNode
+          walk(node.collection, source, patches, statement_level: false)
+          walk(node.statements, source, patches, statement_level: true) if node.statements
+
+        when Prism::DefNode
+          walk(node.body, source, patches, statement_level: true) if node.body
+
+        when Prism::ClassNode, Prism::ModuleNode, Prism::SingletonClassNode
+          walk(node.body, source, patches, statement_level: true) if node.body
+
+        when Prism::BeginNode
+          walk(node.statements, source, patches, statement_level: true) if node.statements
+          walk(node.rescue_clause, source, patches, statement_level: true) if node.rescue_clause
+          walk(node.else_clause, source, patches, statement_level: true) if node.else_clause
+          walk(node.ensure_clause, source, patches, statement_level: true) if node.ensure_clause
+
+        when Prism::RescueNode
+          walk(node.statements, source, patches, statement_level: true) if node.statements
+          walk(node.subsequent, source, patches, statement_level: true) if node.subsequent
+
+        when Prism::EnsureNode
+          walk(node.statements, source, patches, statement_level: true) if node.statements
+
+        when Prism::CaseNode
+          walk(node.predicate, source, patches, statement_level: false) if node.predicate
+          node.conditions.each { |cond| walk(cond, source, patches, statement_level: true) }
+          walk(node.else_clause, source, patches, statement_level: true) if node.else_clause
+
+        when Prism::WhenNode
+          node.conditions.each { |c| walk(c, source, patches, statement_level: false) }
+          walk(node.statements, source, patches, statement_level: true) if node.statements
+
+        when Prism::CaseMatchNode
+          walk(node.predicate, source, patches, statement_level: false) if node.predicate
+          node.conditions.each { |cond| walk(cond, source, patches, statement_level: true) }
+          walk(node.else_clause, source, patches, statement_level: true) if node.else_clause
+
+        when Prism::InNode
+          walk(node.statements, source, patches, statement_level: true) if node.statements
+
+        when Prism::BlockNode, Prism::LambdaNode
+          walk(node.body, source, patches, statement_level: true) if node.body
+
+        when Prism::ParenthesesNode
+          walk(node.body, source, patches, statement_level: statement_level) if node.body
+
+        when Prism::LocalVariableWriteNode
+          walk(node.value, source, patches, statement_level: statement_level)
+
+        when Prism::PostExecutionNode
+          walk(node.statements, source, patches, statement_level: true) if node.statements
+
+        else
+          node.compact_child_nodes.each { |child| walk(child, source, patches, statement_level: false) }
+        end
+      end
+
+      def walk_if(node, source, patches)
+        walk(node.predicate, source, patches, statement_level: false)
+
+        if node.if_keyword_loc
+          # Block-if or modifier-if: body is at statement level
+          walk(node.statements, source, patches, statement_level: true) if node.statements
+          walk(node.subsequent, source, patches, statement_level: true) if node.subsequent
+        else
+          # Ternary (no if_keyword_loc): arms are NOT at statement level
+          walk(node.statements, source, patches, statement_level: false) if node.statements
+          walk(node.subsequent, source, patches, statement_level: false) if node.subsequent
+        end
+      end
+
+      def walk_call_children(node, source, patches)
+        walk(node.receiver, source, patches, statement_level: false) if node.receiver
+        node.arguments&.arguments&.each { |arg| walk(arg, source, patches, statement_level: false) }
+        if node.block
+          if node.block.is_a?(Prism::BlockNode)
+            walk(node.block, source, patches, statement_level: true)
+          else
+            walk(node.block, source, patches, statement_level: false)
+          end
+        end
+      end
+
+      def try_remove_call_parens(node, source, patches)
+        return unless node.opening_loc
+        return unless AstUtils.can_omit_parens?(node)
+
+        # Don't remove parens from calls with keyword args in modifier context.
+        # After hash shorthand (`a:` for `a:a`), `foo a: if cond` is ambiguous.
+        raw_args = node.arguments&.arguments || []
+        if raw_args.any? { |a| a.is_a?(Prism::KeywordHashNode) }
+          # opening_loc presence (checked above) implies the paired closing_loc
+          after = source.byteslice(node.closing_loc.end_offset, 10) # steep:ignore NoMethod
+          return if after&.match?(/\A (?:if|unless|while|until) /)
+        end
+
+        add_paren_removal_patches(node.opening_loc, node.closing_loc, patches) # steep:ignore ArgumentTypeMismatch
+      end
+
+      def try_remove_yield_parens(node, patches)
+        return unless node.lparen_loc
+        args = node.arguments&.arguments || []
+        return if args.empty?
+
+        # lparen_loc presence (checked above) implies the paired rparen_loc
+        add_paren_removal_patches(node.lparen_loc, node.rparen_loc, patches) # steep:ignore ArgumentTypeMismatch
+      end
+
+      def add_paren_removal_patches(open_loc, close_loc, patches)
+        patches << { start: open_loc.start_offset, end: open_loc.end_offset, replacement: ' ' }
+        patches << { start: close_loc.start_offset, end: close_loc.end_offset, replacement: '' }
+      end
+
+    end
+  end
+end