sorbet-eraser 0.4.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3859ee512cb01ed5b84df15af3dedaa629c30d122e80a7436821841f87184562
-  data.tar.gz: 8392610b8fb03ea78d2572b684c2ccf9b4806f082043e3b2614550a370eeea13
+  metadata.gz: fb18fb992ca140f69b3971850f1aa3da26091b6d01ba133656c13d6c2427a80a
+  data.tar.gz: 7e00f8f81e9b90b23bec44a9e943322eddbf51d75f5ae6491787a7674ce3ca6f
 SHA512:
-  metadata.gz: 02ee32fc8bcf3d1951ddd9577a4f46c181a01f196eb6c2af34bb8bb0b68a0ebc3fb28515d0ca1e391d2d1ee305d3012aafd943918df643dd2a3a44c5272a38b2
-  data.tar.gz: fa7b5e80e3fda49d50df015532110f6b4050450c5348f4d9f0ac6f40c8e2b411882a5348b38e305419b74e0bf6e833b887997bb6757e440fb3acc552e286d7e4
+  metadata.gz: c5309fc61086dcd2371ab5784847ffa4695ed99fffe18ee25e74b568bf75e75c6ba8d79baedfd3403471fc11008242ccbc453a39517d1b1ff9863d23240f7e6d
+  data.tar.gz: b8599cb21d63143a9ed9ff27df14849c40422d8425b07552b874a69efee908168f01b6862ac05033551b992f998fd934cdd24c5bd0f177094ca63bbb6dafe92d

data/.github/workflows/auto-merge.yml

@@ -0,0 +1,22 @@
+name: Dependabot auto-merge
+on: pull_request
+
+permissions:
+  contents: write
+  pull-requests: write
+
+jobs:
+  dependabot:
+    runs-on: ubuntu-latest
+    if: ${{ github.actor == 'dependabot[bot]' }}
+    steps:
+      - name: Dependabot metadata
+        id: metadata
+        uses: dependabot/fetch-metadata@v1.3.6
+        with:
+          github-token: "${{ secrets.GITHUB_TOKEN }}"
+      - name: Enable auto-merge for Dependabot PRs
+        run: gh pr merge --auto --merge "$PR_URL"
+        env:
+          PR_URL: ${{github.event.pull_request.html_url}}
+          GITHUB_TOKEN: ${{secrets.GITHUB_TOKEN}}

data/.github/workflows/main.yml

@@ -1,32 +1,24 @@
 name: Main
+
 on:
 - push
-- pull_request_target
+- pull_request
+
 jobs:
   ci:
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby:
+        - '3.1'
+        - '3.2'
     name: CI
     runs-on: ubuntu-latest
-    env:
-      CI: true
     steps:
     - uses: actions/checkout@master
     - uses: ruby/setup-ruby@v1
       with:
-        ruby-version: '3.1'
+        ruby-version: ${{ matrix.ruby }}
         bundler-cache: true
     - name: Test
       run: bundle exec rake test
-  automerge:
-    name: AutoMerge
-    needs: ci
-    runs-on: ubuntu-latest
-    if: github.event_name == 'pull_request_target' && (github.actor == github.repository_owner || github.actor == 'dependabot[bot]')
-    steps:
-    - uses: actions/github-script@v3
-      with:
-        script: |
-          github.pulls.merge({
-            owner: context.payload.repository.owner.login,
-            repo: context.payload.repository.name,
-            pull_number: context.payload.pull_request.number
-          })

data/.gitignore

@@ -6,3 +6,5 @@
 /pkg/
 /spec/reports/
 /tmp/
+
+test.rb

data/CHANGELOG.md

@@ -6,6 +6,21 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) a
 
 ## [Unreleased]
 
+## [0.6.0] - 2023-09-11
+
+### Added
+
+- Swapped out `ripper` for `YARP`.
+
+## [0.5.0] - 2023-07-13
+
+### Added
+
+- Replace `typed: strict` comments with empty comments.
+- Replace all `typed:` sigil comments with empty comments instead of `typed: ignore`. Do this because `typed: ignore` longer than other options, which can cause issues with byte ranges, and violates an assumption by this gem that it is only erasing, not adding content.
+- Add a `--verify` option to the CLI to ensure output is valid Ruby.
+- Enhance `sorbet/eraser/autoload` to hook into `load_iseq` even if bootsnap is not present.
+
 ## [0.4.0] - 2023-07-03
 
 ### Added
@@ -41,7 +56,9 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) a
 
 - Require MFA for releasing.
 
-[unreleased]: https://github.com/kddnewton/sorbet-eraser/compare/v0.4.0...HEAD
+[unreleased]: https://github.com/kddnewton/sorbet-eraser/compare/v0.6.0...HEAD
+[0.6.0]: https://github.com/kddnewton/sorbet-eraser/compare/v0.5.0...v0.6.0
+[0.5.0]: https://github.com/kddnewton/sorbet-eraser/compare/v0.4.0...v0.5.0
 [0.4.0]: https://github.com/kddnewton/sorbet-eraser/compare/v0.3.1...v0.4.0
 [0.3.1]: https://github.com/kddnewton/sorbet-eraser/compare/v0.3.0...v0.3.1
 [0.3.0]: https://github.com/kddnewton/sorbet-eraser/compare/v0.2.0...v0.3.0

data/Gemfile.lock

@@ -1,13 +1,15 @@
 PATH
   remote: .
   specs:
-    sorbet-eraser (0.4.0)
+    sorbet-eraser (0.6.0)
+      yarp
 
 GEM
   remote: https://rubygems.org/
   specs:
-    minitest (5.18.1)
+    minitest (5.20.0)
     rake (13.0.6)
+    yarp (0.11.0)
 
 PLATFORMS
   arm64-darwin-21

data/README.md

@@ -27,19 +27,19 @@ end
 will be transformed into
 
 ```ruby
-             
+#            
 
 class HelloWorld
-               
+  extend T::Sig
 
                          
   def hello
-          "World!"         
+         ("World!"        )
   end
 end
 ```
 
-Notice that the `extend T::Sig` and `sig` constructs have been removed from your source code. Notice also that all line and column information has been preserved 1:1, so that stack traces and tracepoints will still be accurate.
+The `sig` method calls have been removed from your source code. `T::Sig` has been left in place, but is shimmed with an empty module to ensure any reflection is consistent. All line and column information has been preserved 1:1, so that stack traces and tracepoints will still be accurate.
 
 ## Installation
 
@@ -95,30 +95,30 @@ If you used any runtime structures like `T::Struct` or `T::Enum` you'll need a r
 
 Below is a table of the status of each `sorbet-runtime` construct and its current support status.
 
-| Construct                                           | Status | Replacement       |
-| --------------------------------------------------- | ------ | ----------------- |
-| `# typed: foo`                                      | ✅     | `# typed: ignore` |
-| `extend T::*`                                       | ✅     | Shimmed           |
-| `abstract!`, `final!`, `interface!`, `sealed!`      | ✅     | Shimmed           |
-| `mixes_in_class_methods(*)`, `requires_ancestor(*)` | ✅     | Shimmed           |
-| `type_member(*)`, `type_template(*)`                | ✅     | Shimmed           |
-| `class Foo < T::Enum`                               | ✅     | Shimmed           |
-| `class Foo < T::InexactStruct`                      | 🛠     | Shimmed           |
-| `class Foo < T::Struct`                             | 🛠     | Shimmed           |
-| `class Foo < T::ImmutableStruct`                    | 🛠     | Shimmed           |
-| `include T::Props`                                  | 🛠     | Shimmed           |
-| `include T::Props::Serializable`                    | 🛠     | Shimmed           |
-| `include T::Props::Constructor`                     | 🛠     | Shimmed           |
-| `sig`                                               | ✅     | Removed           |
-| `T.absurd(foo)`                                     | ✅     | Shimmed           |
-| `T.assert_type!(foo, bar)`                          | ✅     | `foo`             |
-| `T.bind(self, foo)`                                 | ✅     | `self`            |
-| `T.cast(foo, bar)`                                  | ✅     | `foo`             |
-| `T.let(foo, bar)`                                   | ✅     | `foo`             |
-| `T.must(foo)`                                       | ✅     | `foo`             |
-| `T.reveal_type(foo)`                                | ✅     | `foo`             |
-| `T.type_alias { foo }`                              | ✅     | Shimmed           |
-| `T.unsafe(foo)`                                     | ✅     | `foo`             |
+| Construct                                           | Status | Replacement |
+| --------------------------------------------------- | ------ | ----------- |
+| `# typed: foo`                                      | ✅      | `#`         |
+| `extend T::*`                                       | ✅      | Shimmed     |
+| `abstract!`, `final!`, `interface!`, `sealed!`      | ✅      | Shimmed     |
+| `mixes_in_class_methods(*)`, `requires_ancestor(*)` | ✅      | Shimmed     |
+| `type_member(*)`, `type_template(*)`                | ✅      | Shimmed     |
+| `class Foo < T::Enum`                               | ✅      | Shimmed     |
+| `class Foo < T::InexactStruct`                      | 🛠      | Shimmed     |
+| `class Foo < T::Struct`                             | 🛠      | Shimmed     |
+| `class Foo < T::ImmutableStruct`                    | 🛠      | Shimmed     |
+| `include T::Props`                                  | 🛠      | Shimmed     |
+| `include T::Props::Serializable`                    | 🛠      | Shimmed     |
+| `include T::Props::Constructor`                     | 🛠      | Shimmed     |
+| `sig`                                               | ✅      | Removed     |
+| `T.absurd(foo)`                                     | ✅      | Shimmed     |
+| `T.assert_type!(foo, bar)`                          | ✅      | `foo`       |
+| `T.bind(self, foo)`                                 | ✅      | `self`      |
+| `T.cast(foo, bar)`                                  | ✅      | `foo`       |
+| `T.let(foo, bar)`                                   | ✅      | `foo`       |
+| `T.must(foo)`                                       | ✅      | `foo`       |
+| `T.reveal_type(foo)`                                | ✅      | `foo`       |
+| `T.type_alias { foo }`                              | ✅      | Shimmed     |
+| `T.unsafe(foo)`                                     | ✅      | `foo`       |
 
 In the above table, for `Status`:
 

data/exe/sorbet-eraser

@@ -4,4 +4,11 @@ $:.unshift(File.expand_path("../lib", __dir__))
 require "sorbet/eraser"
 require "sorbet/eraser/cli"
 
-Sorbet::Eraser::CLI.start(ARGV)
+if ENV["BENCHMARK"]
+  require "benchmark"
+  Benchmark.bm do |x|
+    x.report { Sorbet::Eraser::CLI.start(ARGV) }
+  end
+else
+  Sorbet::Eraser::CLI.start(ARGV)
+end

data/lib/sorbet/eraser/autoload.rb

@@ -2,21 +2,21 @@
 
 require "sorbet/eraser"
 
-# Hook into bootsnap so that before the source is compiled through
-# RubyVM::InstructionSequence it gets erased through the eraser.
-if RubyVM::InstructionSequence.method_defined?(:load_iseq)
-  load_iseq, = RubyVM::InstructionSequence.method(:load_iseq).source_location
-
-  if load_iseq.include?("/bootsnap/")
-    module Sorbet::Eraser::Patch
-      def input_to_storage(contents, filepath)
-        erased = Sorbet::Eraser.erase(contents)
-        RubyVM::InstructionSequence.compile(erased, filepath, filepath).to_binary
-      rescue SyntaxError
-        raise ::Bootsnap::CompileCache::Uncompilable, "syntax error"
-      end
+if RubyVM::InstructionSequence.method_defined?(:load_iseq) &&
+   RubyVM::InstructionSequence.method(:load_iseq).source_location[0].include?("/bootsnap/")
+  # If the load_iseq method is defined by bootsnap, then we need to override it.
+  module Sorbet::Eraser::Patch
+    def input_to_storage(contents, filepath)
+      super(Sorbet::Eraser.erase(contents), filepath)
     end
+  end
 
-    Bootsnap::CompileCache::ISeq.singleton_class.prepend(Sorbet::Eraser::Patch)
+  Bootsnap::CompileCache::ISeq.singleton_class.prepend(Sorbet::Eraser::Patch)
+else
+  # Otherwise if the method isn't defined by bootsnap, then we'll define it
+  # ourselves.
+  def (RubyVM::InstructionSequence).load_iseq(filepath)
+    erased = Sorbet::Eraser.erase_filepath(filepath)
+    RubyVM::InstructionSequence.compile(erased, filepath, filepath)
   end
 end

data/lib/sorbet/eraser/bytesplice.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class String
+  # This is a polyfill for the String#bytesplice method that didn't exist before
+  # Ruby 3.2.0, and didn't return the receiver until 3.2.1.
+  def bytesplice(range, value)
+    previous_encoding = encoding
+
+    begin
+      force_encoding(Encoding::ASCII_8BIT)
+      self[range] = value
+    ensure
+      force_encoding(previous_encoding)
+    end
+
+    self
+  end
+end

data/lib/sorbet/eraser/cli.rb

@@ -7,9 +7,10 @@ module Sorbet
     class CLI
       POOL_SIZE = 4
 
-      attr_reader :filepaths
+      attr_reader :verify, :filepaths
 
-      def initialize(filepaths)
+      def initialize(verify, filepaths)
+        @verify = verify
         @filepaths = filepaths
       end
 
@@ -28,22 +29,36 @@ module Sorbet
                 break if filepath == :eoq
                 process(filepath)
               end
-            end
+            end.tap { |thread| thread.abort_on_exception = true }
           end
 
         workers.each(&:join)
       end
 
       def self.start(argv)
-        new(argv.flat_map { |pattern| Dir.glob(pattern) }).start
+        verify = false
+
+        if argv.first == "--verify"
+          verify = true
+          argv.shift
+        end
+
+        filepaths = []
+        argv.each { |pattern| filepaths.concat(Dir.glob(pattern)) }
+
+        new(verify, filepaths).start
       end
 
       private
 
       def process(filepath)
-        File.write(filepath, Eraser.erase(File.read(filepath)))
-      rescue Parser::ParsingError => error
-        warn("Could not parse #{filepath}: #{error}")
+        contents = Eraser.erase_file(filepath)
+
+        if verify && Ripper.sexp_raw(contents).nil?
+          warn("Internal error while parsing #{filepath}")
+        else
+          File.write(filepath, contents)
+        end
       rescue => error
         warn("Could not parse #{filepath}: #{error}")
       end

data/lib/sorbet/eraser/version.rb

@@ -2,6 +2,6 @@
 
 module Sorbet
   module Eraser
-    VERSION = "0.4.0"
+    VERSION = "0.6.0"
   end
 end

data/lib/sorbet/eraser.rb

@@ -1,23 +1,169 @@
 # frozen_string_literal: true
 
-require "ripper"
+require "yarp"
 
-require "sorbet/eraser/parser"
-require "sorbet/eraser/patterns"
 require "sorbet/eraser/version"
-require "t"
+require "sorbet/eraser/t"
+
+# Check if String#bytesplice is supported, and otherwise define it. If it is
+# already defined but doesn't return the receiver, override it.
+if !("".respond_to?(:bytesplice))
+  require "sorbet/eraser/bytesplice"
+elsif (+"aa").bytesplice(0, 1, "z") != "za"
+  class String
+    undef bytesplice
+  end
+
+  require "sorbet/eraser/bytesplice"
+end
 
 module Sorbet
+  # This module contains the logic for erasing Sorbet type annotations from
+  # Ruby source code.
   module Eraser
-    # Hook the patterns into the parser so that the correct methods get
-    # overridden and will trigger replacements.
-    Parser.prepend(Patterns)
-
-    # The entrypoint method to this overall module. This should be called with a
-    # string that represents Ruby source, and it will return the modified Ruby
-    # source.
-    def self.erase(source)
-      Parser.erase(source)
+    # This class is a YARP visitor that finds the ranges of bytes that should be
+    # erased from the source code.
+    class Ranges < YARP::Visitor
+      attr_reader :ranges
+
+      def initialize(ranges)
+        @ranges = ranges
+      end
+
+      def visit_call_node(node)
+        case node.name
+        when "abstract!", "final!", "interface!"
+          # abstract!
+          # abstract!()
+          # final!
+          # final!()
+          # interface!
+          # interface!()
+          if !node.receiver && !node.arguments && !node.block
+            ranges << (node.location.start_offset...node.location.end_offset)
+          end
+        when "assert_type!", "bind", "cast", "let"
+          # T.assert_type! foo, String
+          # T.assert_type!(foo, String)
+          # T.bind self, String
+          # T.bind(self, String)
+          # T.cast foo, String
+          # T.cast(foo, String)
+          # T.let foo, String
+          # T.let(foo, String)
+          if node.receiver.is_a?(YARP::ConstantReadNode) && node.receiver.name == :T && node.arguments && !node.block && node.arguments.arguments.length == 2
+            arguments = node.arguments.arguments
+
+            if node.opening_loc
+              ranges << (node.location.start_offset...node.opening_loc.start_offset)
+              ranges << (arguments.first.location.end_offset...node.closing_loc.start_offset)
+            else
+              ranges << (node.location.start_offset...arguments.first.location.start_offset)
+              ranges << (arguments.last.location.end_offset...node.location.end_offset)
+            end
+          end
+        when "const", "prop"
+          # const :foo, String
+          # const :foo, String, required: true
+          # const(:foo, String)
+          # const(:foo, String, required: true)
+          # prop :foo, String
+          # prop :foo, String, required: true
+          # prop(:foo, String)
+          # prop(:foo, String, required: true)
+          if !node.receiver && node.arguments && !node.block
+            arguments = node.arguments.arguments
+
+            case arguments.length
+            when 2
+              ranges << (arguments[0].location.end_offset...arguments[1].location.end_offset)
+            when 3
+              ranges << (arguments[1].location.start_offset...arguments[2].location.start_offset)
+            end
+          end
+        when "mixes_in_class_methods"
+          # mixes_in_class_methods Foo
+          # mixes_in_class_methods(Foo)
+          if !node.receiver && node.arguments && !node.block && node.arguments.arguments.length == 1
+            ranges << (node.location.start_offset...node.location.end_offset)
+          end
+        when "must", "reveal_type", "unsafe"
+          # T.must foo
+          # T.must(foo)
+          # T.reveal_type foo
+          # T.reveal_type(foo)
+          # T.unsafe foo
+          # T.unsafe(foo)
+          if node.receiver.is_a?(YARP::ConstantReadNode) && node.receiver.name == :T && node.arguments && !node.block && node.arguments.arguments.length == 1
+            argument = node.arguments.arguments.first
+
+            if node.opening_loc
+              ranges << (node.location.start_offset...node.opening_loc.start_offset)
+              ranges << (argument.location.end_offset...node.closing_loc.start_offset)
+            else
+              ranges << (node.location.start_offset...argument.location.start_offset)
+              ranges << (argument.location.end_offset...node.location.end_offset)
+            end
+          end
+        when "sig"
+          # sig { ... }
+          # sig do ... end
+          if !node.receiver && !node.arguments && node.block
+            ranges << (node.location.start_offset...node.location.end_offset)
+          end
+        end
+
+        super
+      end
+    end
+
+    class << self
+      # The is one of the two entrypoints to the module. This should be called
+      # with a string that contains Ruby source. It returns the modified Ruby
+      # source.
+      def erase(source)
+        erase_result(YARP.parse(source), source)
+      end
+
+      # This is one of the two entrypoints to the module. This should be called
+      # with a filepath that points to a file that contains Ruby source. It
+      # returns the modified Ruby source.
+      def erase_file(filepath)
+        erase_result(YARP.parse_file(filepath), File.read(filepath))
+      end
+
+      private
+
+      # Accept a YARP::ParseResult and return a list of ranges that should be
+      # erased from comments that contain typed sigils.
+      def comment_ranges(result, ranges)
+        first = result.value.statements.body.first
+        minimum = first ? first.location.start_line : result.source.offsets.length
+
+        result.comments.each do |comment|
+          # Implicitly assuming that comments are in order.
+          break if comment.location.start_line >= minimum
+
+          if comment.type == :inline && comment.location.slice.match?(/\A#\s*typed:\s*(?:ignore|false|true|strict|strong)\s*\z/)
+            ranges << ((comment.location.start_offset + 1)...comment.location.end_offset)
+          end
+        end
+      end
+
+      # Accept a YARP::ParseResult and return the modified Ruby source.
+      def erase_result(result, source)
+        ranges = []
+
+        result.value.accept(Ranges.new(ranges))
+        comment_ranges(result, ranges)
+
+        ranges.inject(source) do |current, range|
+          # This is deceptive in that it hides that it actually replaces
+          # everything with spaces _except_ newline characters, which is keeps
+          # in place.
+          source.bytesplice(range, source.byteslice(range).gsub(/./, " "))
+        end
+      end
     end
   end
 end

data/sorbet-eraser.gemspec

@@ -30,6 +30,8 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
+  spec.add_dependency "yarp"
+
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "minitest"

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-eraser
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Kevin Newton
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-07-03 00:00:00.000000000 Z
+date: 2023-09-11 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: yarp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -61,6 +75,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".github/dependabot.yml"
+- ".github/workflows/auto-merge.yml"
 - ".github/workflows/main.yml"
 - ".gitignore"
 - CHANGELOG.md
@@ -74,9 +89,8 @@ files:
 - exe/sorbet-eraser
 - lib/sorbet/eraser.rb
 - lib/sorbet/eraser/autoload.rb
+- lib/sorbet/eraser/bytesplice.rb
 - lib/sorbet/eraser/cli.rb
-- lib/sorbet/eraser/parser.rb
-- lib/sorbet/eraser/patterns.rb
 - lib/sorbet/eraser/t.rb
 - lib/sorbet/eraser/t/enum.rb
 - lib/sorbet/eraser/t/props.rb
@@ -89,7 +103,7 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/kddnewton/sorbet-eraser/issues
-  changelog_uri: https://github.com/kddnewton/sorbet-eraser/blob/v0.4.0/CHANGELOG.md
+  changelog_uri: https://github.com/kddnewton/sorbet-eraser/blob/v0.6.0/CHANGELOG.md
   source_code_uri: https://github.com/kddnewton/sorbet-eraser
   rubygems_mfa_required: 'true'
 post_install_message:

data/lib/sorbet/eraser/parser.rb

@@ -1,293 +0,0 @@
-# frozen_string_literal: true
-
-module Sorbet
-  module Eraser
-    # A Ripper parser that will replace usage of Sorbet patterns with whitespace
-    # so that location information is maintained but Sorbet methods aren't
-    # called.
-    class Parser < Ripper
-      # Represents a line in the source. If this class is being used, it means
-      # that every character in the string is 1 byte in length, so we can just
-      # return the start of the line + the index.
-      class SingleByteString
-        def initialize(start)
-          @start = start
-        end
-
-        def [](byteindex)
-          @start + byteindex
-        end
-      end
-
-      # Represents a line in the source. If this class is being used, it means
-      # that there are characters in the string that are multi-byte, so we will
-      # build up an array of indices, such that array[byteindex] will be equal
-      # to the index of the character within the string.
-      class MultiByteString
-        def initialize(start, line)
-          @indices = []
-
-          line
-            .each_char
-            .with_index(start) do |char, index|
-              char.bytesize.times { @indices << index }
-            end
-        end
-
-        def [](byteindex)
-          # Why the || byteindex? I'm not sure. For some reason ripper is
-          # returning very odd column values when you have a multibyte line.
-          # This is the only way I could find to make it work.
-          @indices[byteindex] || byteindex
-        end
-      end
-
-      # Represents a node in the AST. Keeps track of the event that generated
-      # it, any child nodes that descend from it, and the location in the
-      # source.
-      class Node
-        attr_reader :event, :body, :range
-
-        def initialize(event, body, range)
-          @event = event
-          @body = body
-          @range = range
-        end
-
-        def match?(pattern)
-          to_s.match?(pattern)
-        end
-
-        def to_s
-          @repr ||= begin
-            children = body.map { |child| child.is_a?(Array) ? child.map(&:to_s) : child }
-            "<#{event} #{children.join(" ")}>"
-          end
-        end
-      end
-
-      # Raised in the case that source can't be parsed.
-      class ParsingError < StandardError
-      end
-
-      attr_reader :source, :line_counts, :errors, :patterns, :heredocs
-
-      def initialize(source)
-        super(source)
-
-        @source = source
-        @line_counts = []
-        last_index = 0
-
-        source.lines.each do |line|
-          if line.size == line.bytesize
-            @line_counts << SingleByteString.new(last_index)
-          else
-            @line_counts << MultiByteString.new(last_index, line)
-          end
-
-          last_index += line.bytesize
-        end
-
-        @errors = []
-        @patterns = []
-        @heredocs = []
-      end
-
-      def self.erase(source)
-        parser = new(source)
-
-        if parser.parse.nil? || parser.error?
-          raise ParsingError, parser.errors.join("\n")
-        else
-          parser.patterns.inject(source) do |current, pattern|
-            pattern.erase(current)
-          end
-        end
-      end
-
-      private
-
-      def loc
-        line_counts[lineno - 1][column]
-      end
-
-      def find_loc(args)
-        ranges = []
-
-        args.each do |arg|
-          case arg
-          when Node
-            ranges << arg.range if arg.range
-          when Array
-            ranges << find_loc(arg)
-          end
-        end
-
-        case ranges.length
-        when 0
-          nil
-        when 1
-          ranges.first
-        else
-          ranges.first.begin...ranges.last.end
-        end
-      end
-
-      # Better location information for aref.
-      def on_aref(recv, arg)
-        rend = arg.range.end + source[arg.range.end..].index("]") + 1
-        Node.new(:aref, [recv, arg], recv.range.begin...rend)
-      end
-
-      # Better location information for arg_paren.
-      def on_arg_paren(arg)
-        if arg
-          rbegin = source[..arg.range.begin].rindex("(")
-          rend = arg.range.end + source[arg.range.end..].index(")") + 1
-          Node.new(:arg_paren, [arg], rbegin...rend)
-        else
-          segment = source[..loc]
-          Node.new(:arg_paren, [arg], segment.rindex("(")...(segment.rindex(")") + 1))
-        end
-      end
-
-      LISTS = { qsymbols: "%i", qwords: "%w", symbols: "%I", words: "%W" }.freeze
-      TERMINATORS = { "[" => "]", "{" => "}", "(" => ")", "<" => ">" }.freeze
-
-      # Better location information for array.
-      def on_array(arg)
-        case arg&.event
-        when nil
-          segment = source[..loc]
-          Node.new(:array, [arg], segment.rindex("[")...(segment.rindex("]") + 1))
-        when :qsymbols, :qwords, :symbols, :words
-          rbegin = source[...arg.range.begin].rindex(LISTS.fetch(arg.event))
-          rend = source[arg.range.end..].index(TERMINATORS.fetch(source[rbegin + 2]) { source[rbegin + 2] }) + arg.range.end + 1
-          Node.new(:array, [arg], rbegin...rend)
-        else
-          Node.new(:array, [arg], arg.range)
-        end
-      end
-
-      # Better location information for brace_block.
-      def on_brace_block(params, body)
-        if params || body.range
-          rbegin = source[...(params || body).range.begin].rindex("{")
-
-          rend = body.range&.end || params.range.end
-          rend = rend + source[rend..].index("}") + 1
-
-          Node.new(:brace_block, [params, body], rbegin...rend)
-        else
-          segment = source[..loc]
-          Node.new(:brace_block, [params, body], segment.rindex("{")...(segment.rindex("}") + 1))
-        end
-      end
-
-      # Better location information for do_block.
-      def on_do_block(params, body)
-        if params || body.range
-          rbegin = source[...(params || body).range.begin].rindex("do")
-
-          rend = body.range&.end || params.range.end
-          rend = rend + source[rend..].index("end") + 3
-
-          Node.new(:do_block, [params, body], rbegin...rend)
-        else
-          segment = source[..loc]
-          Node.new(:do_block, [params, body], segment.rindex("do")...(segment.rindex("end") + 3))
-        end
-      end
-
-      # Better location information for hash.
-      def on_hash(arg)
-        if arg
-          Node.new(:hash, [arg], arg.range)
-        else
-          segment = source[..loc]
-          Node.new(:hash, [arg], segment.rindex("{")...(segment.rindex("}") + 1))
-        end
-      end
-
-      # Track the open heredocs so we can replace the string literal ranges with
-      # the range of their declarations.
-      def on_heredoc_beg(value)
-        range = loc.then { |start| start...(start + value.bytesize) }
-        heredocs << [range, value, nil]
-
-        Node.new(:@heredoc_beg, [value], range)
-      end
-
-      # If a heredoc ends, then the next string literal event will be the
-      # heredoc.
-      def on_heredoc_end(value)
-        range = loc.then { |start| start...(start + value.bytesize) }
-        heredocs.find { |(_, beg_arg, end_arg)| beg_arg.include?(value.strip) && end_arg.nil? }[2] = value
-
-        Node.new(:@heredoc_end, [value], range)
-      end
-
-      # Track the parsing errors for nicer error messages.
-      def on_parse_error(error)
-        errors << "line #{lineno}: #{error}"
-      end
-
-      # Better location information for string_literal taking into account
-      # heredocs.
-      def on_string_literal(arg)
-        if heredoc = heredocs.find { |(_, _, end_arg)| end_arg }
-          Node.new(:string_literal, [arg], heredocs.delete(heredoc)[0])
-        else
-          Node.new(:string_literal, [arg], arg.range)
-        end
-      end
-
-      handled = private_instance_methods(false)
-
-      # Loop through all of the scanner events and define a basic method that
-      # wraps everything into a node class.
-      SCANNER_EVENTS.each do |event|
-        next if handled.include?(:"on_#{event}")
-
-        define_method(:"on_#{event}") do |value|
-          range = loc.then { |start| start...(start + (value&.bytesize || 0)) }
-          Node.new(:"@#{event}", [value], range)
-        end
-      end
-
-      # Loop through the parser events and generate a method for each event. If
-      # it's one of the _new methods, then use arrays like SexpBuilderPP. If
-      # it's an _add method then just append to the array. If it's a normal
-      # method, then create a new node and determine its bounds.
-      PARSER_EVENT_TABLE.each do |event, arity|
-        next if handled.include?(:"on_#{event}")
-
-        if event =~ /\A(.+)_new\z/ && event != :assoc_new
-          prefix = $1.to_sym
-
-          define_method(:"on_#{event}") do
-            Node.new(prefix, [], nil)
-          end
-        elsif event =~ /_add\z/
-          define_method(:"on_#{event}") do |node, value|
-            range =
-              if node.body.empty?
-                value.range
-              elsif node.range && value.range
-                (node.range.begin...value.range.end)
-              else
-                node.range || value.range
-              end
-
-            node.class.new(node.event, node.body + [value], range)
-          end
-        else
-          define_method(:"on_#{event}") do |*args|
-            Node.new(event, args, find_loc(args))
-          end
-        end
-      end
-    end
-  end
-end

data/lib/sorbet/eraser/patterns.rb

@@ -1,250 +0,0 @@
-# frozen_string_literal: true
-
-module Sorbet
-  module Eraser
-    module Patterns
-      # A pattern in code that represents a call to a special Sorbet method.
-      class Pattern
-        attr_reader :range, :metadata
-
-        def initialize(range, **metadata)
-          @range = range
-          @metadata = metadata
-        end
-
-        def erase(source)
-          original = source[range]
-          replaced = replace(original)
-
-          # puts "Replacing #{original} (len=#{original.length}) " \
-          #      "with #{replaced} (len=#{replaced.length})"
-
-          source[range] = replaced
-          source
-        end
-
-        def blank(segment)
-          # This is deceptive in that it hides that it actually replaces
-          # everything with spaces _except_ newline characters, which is keeps
-          # in place.
-          segment.gsub(/./, " ")
-        end
-
-        def replace(segment)
-          segment
-        end
-      end
-
-      # T.must(foo) => foo
-      # T.reveal_type(foo) => foo
-      # T.unsafe(foo) => foo
-      class TOneArgMethodCallParensPattern < Pattern
-        def replace(segment)
-          segment.gsub(/(T\s*\.(?:must|reveal_type|unsafe)\(\s*)(.+)(\s*\))(.*)/m) do
-            "#{blank($1)}#{$2}#{blank($3)}#{$4}"
-          end
-        end
-      end
-
-      # T.assert_type!(foo, bar) => foo
-      # T.bind(self, foo) => self
-      # T.cast(foo, bar) => foo
-      # T.let(foo, bar) => let
-      class TTwoArgMethodCallParensPattern < Pattern
-        def replace(segment)
-          replacement = segment.dup
-
-          # We can't really rely on regex here because commas have semantic
-          # meaning and you might have some in the value of the first argument.
-          comma = metadata.fetch(:comma)
-          pre, post = 0..comma, (comma + 1)..-1
-
-          replacement[pre] =
-            replacement[pre].gsub(/(T\s*\.(?:assert_type!|bind|cast|let)\(\s*)(.+)(\s*,)(.*)/m) do
-              "#{blank($1)}#{$2}#{blank($3)}#{$4}"
-            end
-
-          replacement[post] = blank(replacement[post])
-          replacement
-        end
-      end
-
-      # abstract! =>
-      # final! =>
-      # interface! =>
-      class DeclarationPattern < Pattern
-        def replace(segment)
-          segment.gsub(/((?:abstract|final|interface)!(?:\(\s*\))?)(.*)/) do
-            "#{blank($1)}#{$2}"
-          end
-        end
-      end
-
-      # mixes_in_class_methods(foo) => foo
-      class MixesInClassMethodsPattern < Pattern
-        def replace(segment)
-          segment.gsub(/(mixes_in_class_methods\(\s*)(.+)(\s*\))(.*)/m) do
-            "#{blank($1)}#{$2}#{blank($3)}#{$4}"
-          end
-        end
-      end
-
-      # T.must foo => foo
-      # T.reveal_type foo => foo
-      # T.unsafe foo => foo
-      class TMustNoParensPattern < Pattern
-        def replace(segment)
-          segment.gsub(/(T\s*\.(?:must|reveal_type|unsafe)\s*)(.+)/) do
-            "#{blank($1)}#{$2}"
-          end
-        end
-      end
-
-      # typed: ignore
-      # typed: false
-      # typed: true
-      # typed: strong
-      class TypedCommentPattern < Pattern
-        def replace(segment)
-          segment.gsub(/(\A#\s*typed:\s*)(?:ignore|false|true|strong)(\s*)\z/) do
-            "#{$1}ignore#{$2}"
-          end
-        end
-      end
-
-      def on_comment(comment)
-        super.tap do |node|
-          if lineno == 1 && comment.match?(/\A#\s*typed:\s*(?:ignore|false|true|strong)\s*\z/)
-            # typed: ignore
-            # typed: false
-            # typed: true
-            # typed: strong
-            patterns << TypedCommentPattern.new(node.range)
-          end
-        end
-      end
-
-      def on_method_add_arg(call, arg_paren)
-        if call.match?(/\A<call <var_ref <@const T>> <@period \.> <@ident (?:must|reveal_type|unsafe)>>\z/) && arg_paren.match?(/\A<arg_paren <args_add_block <args .+> false>>\z/)
-          # T.must(foo)
-          # T.reveal_type(foo)
-          # T.unsafe(foo)
-          patterns << TOneArgMethodCallParensPattern.new(call.range.begin...arg_paren.range.end)
-        elsif call.match?(/\A<call <var_ref <@const T>> <@period \.> <@ident (?:assert_type!|cast|let)>>\z/) && arg_paren.match?(/\A<arg_paren <args_add_block <args .+> false>>\z/)
-          # T.assert_type!(foo, bar)
-          # T.cast(foo, bar)
-          # T.let(foo, bar)
-          patterns << TTwoArgMethodCallParensPattern.new(
-            call.range.begin...arg_paren.range.end,
-            comma: arg_paren.body[0].body[0].body[0].range.end - call.range.begin
-          )
-        elsif call.match?(/\A<call <var_ref <@const T>> <@period \.> <@ident bind>>\z/) && arg_paren.match?(/\A<arg_paren <args_add_block <args <var_ref <@kw self>> .+> false>>\z/)
-          # T.bind(self, foo)
-          patterns << TTwoArgMethodCallParensPattern.new(
-            call.range.begin...arg_paren.range.end,
-            comma: arg_paren.body[0].body[0].body[0].range.end - call.range.begin
-          )
-        elsif call.match?(/\A<fcall <@ident (?:abstract|final|interface)!>>\z/) && arg_paren.match?("<args >")
-          # abstract!
-          # final!
-          # interface!
-          patterns << DeclarationPattern.new(call.range)
-        elsif call.match?("<fcall <@ident mixes_in_class_methods>>") && arg_paren.match?(/\A<arg_paren <args_add_block <args <.+>>> false>>\z/)
-          # mixes_in_class_methods(foo)
-          patterns << MixesInClassMethodsPattern.new(call.range.begin...arg_paren.range.end)
-        end
-
-        super
-      end
-
-      # prop :foo, String => prop :foo
-      # const :foo, String => const :foo
-      class PropWithoutOptionsPattern < Pattern
-        def replace(segment)
-          segment.dup.tap do |replacement|
-            range = metadata.fetch(:comma)..-1
-            replacement[range] = blank(replacement[range])
-          end
-        end
-      end
-
-      # prop :foo, String, default: "" => prop :foo, default: ""
-      # const :foo, String, default: "" => const :foo, default: ""
-      class PropWithOptionsPattern < Pattern
-        def replace(segment)
-          segment.dup.tap do |replacement|
-            first_comma = metadata.fetch(:first_comma)
-            second_comma = metadata.fetch(:second_comma)
-
-            range = (first_comma + 1)..second_comma
-            replacement[range] = blank(replacement[range])
-          end
-        end
-      end
-
-      def on_command(ident, args_add_block)
-        if ident.match?(/\A<@ident (?:const|prop)>\z/)
-          if args_add_block.match?(/\A<args_add_block <args <symbol_literal <symbol <@ident .+?>>> <.+> <bare_assoc_hash .+> false>\z/)
-            # prop :foo, String, default: ""
-            # const :foo, String, default: ""
-            patterns << PropWithOptionsPattern.new(
-              ident.range.begin..args_add_block.range.end,
-              first_comma: args_add_block.body[0].body[0].range.end - ident.range.begin,
-              second_comma: args_add_block.body[0].body[1].range.end - ident.range.begin
-            )
-          elsif args_add_block.match?(/\A<args_add_block <args <symbol_literal <symbol <@ident .+?>>> <.+> false>\z/)
-            # prop :foo, String
-            # const :foo, String
-            patterns << PropWithoutOptionsPattern.new(
-              ident.range.begin..args_add_block.range.end,
-              comma: args_add_block.body[0].body[0].range.end - ident.range.begin
-            )
-          end
-        end
-
-        super
-      end
-
-      def on_command_call(var_ref, period, ident, args_add_block)
-        if var_ref.match?("<var_ref <@const T>>") && period.match?("<@period .>") && ident.match?(/\A<@ident (?:must|reveal_type|unsafe)>\z/) && args_add_block.match?(/\A<args_add_block <args <.+>> false>\z/) && args_add_block.body[0].body.length == 1
-          # T.must foo
-          # T.reveal_type foo
-          # T.unsafe foo
-          patterns << TMustNoParensPattern.new(var_ref.range.begin..args_add_block.range.end)
-        end
-
-        super
-      end
-
-      # sig { foo } =>
-      class SigBracesPattern < Pattern
-        def replace(segment)
-          segment.gsub(/(sig\s*\{.+\})(.*)/m) do
-            "#{blank($1)}#{$2}"
-          end
-        end
-      end
-
-      # sig do foo end =>
-      class SigBlockPattern < Pattern
-        def replace(segment)
-          segment.gsub(/(sig\s*do.+end)(.*)/m) do
-            "#{blank($1)}#{$2}"
-          end
-        end
-      end
-
-      def on_stmts_add(node, value)
-        if value.match?(/\A<method_add_block <method_add_arg <fcall <@ident sig>> <args >> <brace_block  <stmts .+>>>\z/)
-          # sig { foo }
-          patterns << SigBracesPattern.new(value.range)
-        elsif value.match?(/\A<method_add_block <method_add_arg <fcall <@ident sig>> <args >> <do_block  <bodystmt .+>>>\z/)
-          # sig do foo end
-          patterns << SigBlockPattern.new(value.range)
-        end
-
-        super
-      end
-    end
-  end
-end