sorbet-eraser 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 839924a4d5d33c9f00287b6be5151b263ef6b4446b524568ee0bbb212f2a4584
+  data.tar.gz: 5658154f4303ffa3f547992d679f62efa5f613eb0cf7cb871e51cecb21d7c329
+SHA512:
+  metadata.gz: ae54ad36caaee0aaf2f70eba22fa6e1e9fe3b00b682d00a2007b50076e211d5e4922474a59820193a673e26f76f3b0f63bc2662021577e07cccc5f9d5a8ec55f
+  data.tar.gz: 257cb54108d56dbe36bf10316a2191bc594c59bfa4c4eff358b005703b2a01767ca432c558cc6785f5ad0ac4a918eddef3fca3c15b1c3b17941ca085c8f784fd

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,22 @@
+PATH
+  remote: .
+  specs:
+    sorbet-eraser (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    minitest (5.14.4)
+    rake (13.0.6)
+
+PLATFORMS
+  x86_64-darwin-19
+
+DEPENDENCIES
+  bundler
+  minitest
+  rake
+  sorbet-eraser!
+
+BUNDLED WITH
+   2.2.24

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021-present Kevin Newton
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,70 @@
+# Sorbet::Eraser
+
+Erase all traces of `sorbet-runtime` code.
+
+`sorbet` is a great tool for development. However, in production, it incurs a penalty because it still functions as Ruby code. Even if you completely shim all `sorbet-runtime` method calls (for example by replacing `sig {} ` with a method that immediately returns) you still pay the cost of a method call in the first place.
+
+This gem takes a different approach, but entirely eliminating the `sig` method call (as well as all the other `sorbet-runtime` constructs) from the source before Ruby compiles it.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'sorbet-eraser'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install sorbet-eraser
+
+## Usage
+
+Before any code is loaded that would require a `sorbet-runtime` construct, call `require "sorbet/eraser/autoload"`. This will hook into the autoload process to erase all `sorbet-runtime` code before it gets passed to Ruby to parse.
+
+Alternatively, you can programmatically use this gem through the `Sorbet::Eraser.erase(source)` API, where `source` is a string that represents valid Ruby code. Ruby code without the listed constructs will be returned.
+
+### Status
+
+Below is a table of the status of each `sorbet-runtime` construct and its current support status.
+
+| Construct | Status | Replacement |
+| --------- | ------ | ----------- |
+| `include T::Generic` | 🛠 | |
+| `include T::Helpers` | 🛠 | |
+| `extend T::Sig` | ✅ | |
+| `class Foo < T::Enum` | 🛠 | `class Foo < ::Sorbet::Eraser::Enum` |
+| `class Foo < T::Struct` | 🛠 | `class Foo < ::Sorbet::Eraser::Struct` |
+| `abstract!` | 🛠 | |
+| `final!` | 🛠 | |
+| `interface!` | 🛠 | |
+| `mixes_in_class_methods(foo)` | 🛠 | `foo` |
+| `sig` | ✅ | |
+| `T.absurd(foo)` | ✅ | `raise ::Sorbet::Eraser::AbsurdError` |
+| `T.assert_type!(foo)` | ✅ | `foo` |
+| `T.bind(self, foo)` | ✅ | `self` |
+| `T.cast(foo, bar)` | ✅ | `foo` |
+| `T.let(foo, bar)` | ✅ | `foo` |
+| `T.must(foo)` | ✅ | `foo` |
+| `T.must foo` | ✅ | `foo` |
+| `T.reveal_type(foo)` | ✅ | `foo` |
+| `T.type_alias { foo }` | ✅ | `::Sorbet::Eraser::TypeAlias` |
+| `T.unsafe(foo)` | 🛠 | `foo` |
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/kddnewton/sorbet-eraser.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task default: :test

data/bin/console

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "sorbet/eraser"
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install

data/lib/sorbet/eraser.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "ripper"
+
+require "sorbet/eraser/parser"
+require "sorbet/eraser/patterns"
+require "sorbet/eraser/version"
+
+module Sorbet
+  module Eraser
+    # This error gets raise in place of any T.absurd calls.
+    class AbsurdError < StandardError
+    end
+
+    # This class gets put in place of any existing T.type_alias calls.
+    class TypeAlias
+    end
+
+    # 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)
+    end
+  end
+end

data/lib/sorbet/eraser/autoload.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+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
+    end
+
+    Bootsnap::CompileCache::ISeq.singleton_class.prepend(Sorbet::Eraser::Patch)
+  end
+end

data/lib/sorbet/eraser/parser.rb

@@ -0,0 +1,147 @@
+# 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)
+          @indices[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
+          @to_s ||= "<#{event} #{body.map(&:to_s).join(" ")}>"
+        end
+      end
+
+      attr_reader :line_counts, :patterns
+
+      def initialize(source)
+        super(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.size
+        end
+
+        @patterns = []
+      end
+
+      def self.erase(source)
+        parser = new(source)
+
+        if parser.parse.nil? || parser.error?
+          raise "Invalid source"
+        else
+          parser.patterns.inject(source) do |current, pattern|
+            pattern.erase(current)
+          end
+        end
+      end
+
+      private
+
+      def loc
+        line_counts[lineno - 1][column]
+      end
+
+      # Loop through all of the scanner events and define a basic method that
+      # wraps everything into a node class.
+      SCANNER_EVENTS.each do |event|
+        define_method(:"on_#{event}") do |value|
+          range = loc.then { |start| start..(start + (value&.size || 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|
+        case event
+        when /\A(.+)_new\z/
+          prefix = $1.to_sym
+
+          define_method(:"on_#{event}") do
+            Node.new(prefix, [], loc.then { |start| start..start })
+          end
+        when /_add\z/
+          define_method(:"on_#{event}") do |node, value|
+            range =
+              if node.body.empty?
+                value.range
+              else
+                (node.range.begin..value.range.end)
+              end
+
+            node.class.new(node.event, node.body + [value], range)
+          end
+        else
+          define_method(:"on_#{event}") do |*args|
+            first, *, last = args.grep(Node).map(&:range)
+
+            first ||= loc.then { |start| start..start }
+            last ||= first
+
+            Node.new(event, args, first.begin..[last.end, loc].max)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sorbet/eraser/patterns.rb

@@ -0,0 +1,173 @@
+# 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
+
+        def initialize(range)
+          @range = range
+        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 replace(segment)
+          segment
+        end
+      end
+
+      # T.absurd(foo) => raise ::Sorbet::Eraser::AbsurdError
+      class TAbsurdParensPattern < Pattern
+        def replace(segment)
+          segment.gsub(/(T\s*\.absurd\(\s*.+\s*\))(.*)/) do
+            replacement = "raise ::Sorbet::Eraser::AbsurdError"
+            "#{replacement}#{" " * [$1.length - replacement.length, 0].max}#{$2}"
+          end
+        end
+      end
+
+      # T.must(foo) => foo
+      # T.reveal_type(foo) => foo
+      class TOneArgMethodCallParensPattern < Pattern
+        def replace(segment)
+          segment.gsub(/(T\s*\.(?:must|reveal_type)\(\s*)(.+)(\s*\))(.*)/) do
+            "#{" " * $1.length}#{$2}#{" " * $3.length}#{$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)
+          segment.gsub(/(T\s*\.(?:assert_type!|bind|cast|let)\(\s*)(.+)(\s*,.+\))(.*)/) do
+            "#{" " * $1.length}#{$2}#{" " * $3.length}#{$4}"
+          end
+        end
+      end
+
+      def on_method_add_arg(call, arg_paren)
+        # T.absurd(foo)
+        if call.match?(/<call <var_ref <@const T>> <@period \.> <@ident absurd>>/) &&
+          arg_paren.match?(/<arg_paren <args_add_block <args .+> false>>/)
+          patterns << TAbsurdParensPattern.new(call.range.begin..arg_paren.range.end)
+        end
+
+        # T.must(foo)
+        # T.reveal_type(foo)
+        if call.match?(/<call <var_ref <@const T>> <@period \.> <@ident (?:must|reveal_type)>>/) &&
+          arg_paren.match?(/<arg_paren <args_add_block <args .+> false>>/)
+          patterns << TOneArgMethodCallParensPattern.new(call.range.begin..arg_paren.range.end)
+        end
+
+        # T.assert_type!(foo, bar)
+        # T.cast(foo, bar)
+        # T.let(foo, bar)
+        if call.match?(/<call <var_ref <@const T>> <@period \.> <@ident (?:assert_type!|cast|let)>>/) &&
+          arg_paren.match?(/<arg_paren <args_add_block <args .+> false>>/)
+          patterns << TTwoArgMethodCallParensPattern.new(call.range.begin..arg_paren.range.end)
+        end
+
+        # T.bind(self, foo)
+        if call.match?(/<call <var_ref <@const T>> <@period \.> <@ident bind>>/) &&
+          arg_paren.match?(/<arg_paren <args_add_block <args <var_ref <@kw self>> .+> false>>/)
+          patterns << TTwoArgMethodCallParensPattern.new(call.range.begin..arg_paren.range.end)
+        end
+
+        super
+      end
+
+      # T.type_alias { foo } => ::Sorbet::Eraser::TypeAlias
+      class TTypeAliasBraceBlockPattern < Pattern
+        def replace(segment)
+          segment.gsub(/(T\s*\.type_alias\s*\{.*\})(.*)/) do
+            replacement = "::Sorbet::Eraser::TypeAlias"
+            "#{replacement}#{" " * [$1.length - replacement.length, 0].max}#{$2}"
+          end
+        end
+      end
+
+      def on_method_add_block(method_add_arg, block)
+        # T.type_alias { foo }
+        if method_add_arg.match?("<call <var_ref <@const T>> <@period .> <@ident type_alias>>") &&
+          block.match?(/<brace_block  <stmts .+>>/)
+          patterns << TTypeAliasBraceBlockPattern.new(method_add_arg.range.begin..block.range.end)
+        end
+
+        super
+      end
+
+      # extend T::Sig =>
+      class ExtendTSigPattern < Pattern
+        def replace(segment)
+          segment.gsub(/(extend\s+T::Sig)(.*)/) do
+            "#{" " * $1.length}#{$2}"
+          end
+        end
+      end
+
+      def on_command(ident, args_add_block)
+        # extend T::Sig
+        if ident.match?("<@ident extend>") &&
+          args_add_block.match?("<args_add_block <args <const_path_ref <var_ref <@const T>> <@const Sig>>> false>")
+          patterns << ExtendTSigPattern.new(ident.range.begin..args_add_block.range.end)
+        end
+
+        super
+      end
+
+      # T.must foo => foo
+      class TMustNoParensPattern < Pattern
+        def replace(segment)
+          segment.gsub(/(T\s*\.must\s*)(.+)/) do
+            "#{" " * $1.length}#{$2}"
+          end
+        end
+      end
+
+      def on_command_call(var_ref, period, ident, args_add_block)
+        if var_ref.match?("<var_ref <@const T>>") && period.match?("<@period .>")
+          # T.must foo
+          if ident.match?("<@ident must>") &&
+            args_add_block.match?(/<args_add_block <args <.+>> false>/) &&
+            args_add_block.body[0].body.length == 1
+            patterns << TMustNoParensPattern.new(var_ref.range.begin..args_add_block.range.end)
+          end
+        end
+
+        super
+      end
+
+      # sig { foo } =>
+      class SigBracesPattern < Pattern
+        def replace(segment)
+          segment.gsub(/(sig\s*\{.+\})(.*)/) do
+            "#{" " * $1.length}#{$2}"
+          end
+        end
+      end
+
+      def on_stmts_add(node, value)
+        # sig { foo }
+        if value.match?(/<method_add_block <method_add_arg <fcall <@ident sig>> <args >> <brace_block  <stmts .+>>>/)
+          patterns << SigBracesPattern.new(value.range)
+        end
+
+        super
+      end
+    end
+  end
+end

data/lib/sorbet/eraser/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Sorbet
+  module Eraser
+    VERSION = "0.1.0"
+  end
+end

data/sorbet-eraser.gemspec

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "sorbet/eraser/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "sorbet-eraser"
+  spec.version       = Sorbet::Eraser::VERSION
+  spec.authors       = ["Kevin Newton"]
+  spec.email         = ["kddnewton@gmail.com"]
+
+  spec.summary       = "Erase all traces of sorbet-runtime code."
+  spec.homepage      = "https://github.com/kddnewton/sorbet-eraser"
+  spec.license       = "MIT"
+
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "minitest"
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: sorbet-eraser
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Kevin Newton
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2021-08-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description:
+email:
+- kddnewton@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/sorbet/eraser.rb
+- lib/sorbet/eraser/autoload.rb
+- lib/sorbet/eraser/parser.rb
+- lib/sorbet/eraser/patterns.rb
+- lib/sorbet/eraser/version.rb
+- sorbet-eraser.gemspec
+homepage: https://github.com/kddnewton/sorbet-eraser
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.3
+signing_key:
+specification_version: 4
+summary: Erase all traces of sorbet-runtime code.
+test_files: []