sorbet-eraser 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 839924a4d5d33c9f00287b6be5151b263ef6b4446b524568ee0bbb212f2a4584
-  data.tar.gz: 5658154f4303ffa3f547992d679f62efa5f613eb0cf7cb871e51cecb21d7c329
+  metadata.gz: 54913e2de72273efae7221b3dc96923c1b45e7d17020ec47bd9a417bea9a62cc
+  data.tar.gz: 71f3cc0a28acefd20d9a4a1f3a06081a568c5b8276cb1241f34d2bb3e7f64fb8
 SHA512:
-  metadata.gz: ae54ad36caaee0aaf2f70eba22fa6e1e9fe3b00b682d00a2007b50076e211d5e4922474a59820193a673e26f76f3b0f63bc2662021577e07cccc5f9d5a8ec55f
-  data.tar.gz: 257cb54108d56dbe36bf10316a2191bc594c59bfa4c4eff358b005703b2a01767ca432c558cc6785f5ad0ac4a918eddef3fca3c15b1c3b17941ca085c8f784fd
+  metadata.gz: 06ca1f48f68eea0d10933f83ffe8ba4b296cda3c87240a5db6704ac27d9d6a12202a46b1af82ee3983ba335d4254f230a8f3d861578556ee76ea3544c551cd70
+  data.tar.gz: 547b88a3fb93e133c69cdd2d05ce684f62cc1650afe836fe9741059d1f567f4704bf11815b3170d8f4df2a9909fcc138fc6d940b45ef5ff615853f93118a2f93

data/.github/dependabot.yml

@@ -0,0 +1,6 @@
+version: 2
+updates:
+  - package-ecosystem: "bundler"
+    directory: "/"
+    schedule:
+      interval: "daily"

data/.github/workflows/main.yml

@@ -0,0 +1,32 @@
+name: Main
+on:
+- push
+- pull_request_target
+jobs:
+  ci:
+    name: CI
+    runs-on: ubuntu-latest
+    env:
+      CI: true
+    steps:
+    - uses: actions/checkout@master
+    - uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: 3.0
+        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/CHANGELOG.md

@@ -0,0 +1,16 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.1.1] - 2021-11-17
+
+### Changed
+
+- Require MFA for releasing.
+
+[unreleased]: https://github.com/kddnewton/sorbet-eraser/compare/v0.1.1...HEAD
+[0.1.1]: https://github.com/kddnewton/sorbet-eraser/compare/f6a712...v0.1.1

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    sorbet-eraser (0.1.0)
+    sorbet-eraser (0.1.1)
 
 GEM
   remote: https://rubygems.org/
@@ -19,4 +19,4 @@ DEPENDENCIES
   sorbet-eraser!
 
 BUNDLED WITH
-   2.2.24
+   2.2.15

data/README.md

@@ -1,5 +1,8 @@
 # Sorbet::Eraser
 
+[![Build Status](https://github.com/kddnewton/sorbet-eraser/workflows/Main/badge.svg)](https://github.com/kddnewton/sorbet-eraser/actions)
+[![Gem](https://img.shields.io/gem/v/sorbet-eraser.svg)](https://rubygems.org/gems/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.
@@ -11,7 +14,7 @@ This gem takes a different approach, but entirely eliminating the `sig` method c
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'sorbet-eraser'
+gem "sorbet-eraser"
 ```
 
 And then execute:
@@ -28,32 +31,42 @@ Before any code is loaded that would require a `sorbet-runtime` construct, call
 
 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.
 
+Finally, this gem ships with a CLI that you can use to modify source files. This is useful for development of this gem itself, but could be useful for others to ensure they see what this gem actually will be doing in production. To run it, run:
+
+```sh
+bundle exec sorbet-eraser '**/*.rb'
+```
+
+It accepts any number of filepaths/patterns on the command line and will modify the source files with their erased contents.
+
 ### 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` |
+| Construct                                           | Status | Replacement |
+| --------------------------------------------------- | ------ | ----------- |
+| `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::Struct`                             | 🛠     | 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:
+
+* `Shimmed` means that this gem provides a replacement module that will simply do nothing when its respective methods are called. We do this in order to maintain the same interface in the case that someone is doing runtime reflection. Also because anything that is shimmed will not be called that much/will not be in a hot path so performance is not really a consideration for those cases.
+* `Removed` means that the construct is removed entirely from the source.
+* Anything else means that the inputted code is replaced with that output.
 
 ## Development
 

data/exe/sorbet-eraser

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+$:.unshift(File.expand_path("../lib", __dir__))
+require "sorbet/eraser"
+require "sorbet/eraser/cli"
+
+Sorbet::Eraser::CLI.start(ARGV)

data/lib/sorbet/eraser/cli.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Sorbet
+  module Eraser
+    # A small CLI that takes filepaths and erases them by writing back to the
+    # original file.
+    class CLI
+      POOL_SIZE = 4
+
+      attr_reader :filepaths
+
+      def initialize(filepaths)
+        @filepaths = filepaths
+      end
+
+      def start
+        queue = Queue.new
+        filepaths.each { |filepath| queue << filepath }
+
+        workers =
+          POOL_SIZE.times.map do
+            # push a symbol onto the queue for each thread so that it knows when
+            # the end of the queue is and will exit its infinite loop
+            queue << :eoq
+
+            Thread.new do
+              while filepath = queue.shift
+                break if filepath == :eoq
+                process(filepath)
+              end
+            end
+          end
+
+        workers.each(&:join)
+      end
+
+      def self.start(argv)
+        new(argv.flat_map { |pattern| Dir.glob(pattern) }).start
+      end
+
+      private
+
+      def process(filepath)
+        File.write(filepath, Eraser.erase(File.read(filepath)))
+      rescue Parser::ParsingError => error
+        warn("Could not parse #{filepath}: #{error}")
+      rescue => error
+        warn("Could not parse #{filepath}: #{error}")
+      end
+    end
+  end
+end

data/lib/sorbet/eraser/parser.rb

@@ -35,7 +35,10 @@ module Sorbet
         end
 
         def [](byteindex)
-          @indices[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
 
@@ -60,11 +63,16 @@ module Sorbet
         end
       end
 
-      attr_reader :line_counts, :patterns
+      # Raised in the case that source can't be parsed.
+      class ParsingError < StandardError
+      end
+
+      attr_reader :source, :line_counts, :errors, :patterns
 
       def initialize(source)
         super(source)
 
+        @source = source
         @line_counts = []
         last_index = 0
 
@@ -78,6 +86,7 @@ module Sorbet
           last_index += line.size
         end
 
+        @errors = []
         @patterns = []
       end
 
@@ -85,7 +94,7 @@ module Sorbet
         parser = new(source)
 
         if parser.parse.nil? || parser.error?
-          raise "Invalid source"
+          raise ParsingError, parser.errors.join("\n")
         else
           parser.patterns.inject(source) do |current, pattern|
             pattern.erase(current)
@@ -113,14 +122,13 @@ module Sorbet
       # 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/
+        if event =~ /\A(.+)_new\z/ && event != :assoc_new
           prefix = $1.to_sym
 
           define_method(:"on_#{event}") do
             Node.new(prefix, [], loc.then { |start| start..start })
           end
-        when /_add\z/
+        elsif event =~ /_add\z/
           define_method(:"on_#{event}") do |node, value|
             range =
               if node.body.empty?
@@ -131,6 +139,8 @@ module Sorbet
 
             node.class.new(node.event, node.body + [value], range)
           end
+        elsif event == :parse_error
+          # skip this, as we're going to define it below
         else
           define_method(:"on_#{event}") do |*args|
             first, *, last = args.grep(Node).map(&:range)
@@ -142,6 +152,11 @@ module Sorbet
           end
         end
       end
+
+      # Track the parsing errors for nicer error messages.
+      def on_parse_error(error)
+        errors << "line #{lineno}: #{error}"
+      end
     end
   end
 end

data/lib/sorbet/eraser/patterns.rb

@@ -5,10 +5,11 @@ module Sorbet
     module Patterns
       # A pattern in code that represents a call to a special Sorbet method.
       class Pattern
-        attr_reader :range
+        attr_reader :range, :metadata
 
-        def initialize(range)
+        def initialize(range, **metadata)
           @range = range
+          @metadata = metadata
         end
 
         def erase(source)
@@ -22,27 +23,25 @@ module Sorbet
           source
         end
 
-        def replace(segment)
-          segment
+        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
-      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
+          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)\(\s*)(.+)(\s*\))(.*)/) do
-            "#{" " * $1.length}#{$2}#{" " * $3.length}#{$4}"
+          segment.gsub(/(T\s*\.(?:must|reveal_type|unsafe)\(\s*)(.+)(\s*\))(.*)/m) do
+            "#{blank($1)}#{$2}#{blank($3)}#{$4}"
           end
         end
       end
@@ -53,87 +52,98 @@ module Sorbet
       # 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}"
+          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
 
-      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)
+      # 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
 
+      def on_method_add_arg(call, arg_paren)
         # T.must(foo)
         # T.reveal_type(foo)
-        if call.match?(/<call <var_ref <@const T>> <@period \.> <@ident (?:must|reveal_type)>>/) &&
+        # T.unsafe(foo)
+        if call.match?(/<call <var_ref <@const T>> <@period \.> <@ident (?:must|reveal_type|unsafe)>>/) &&
           arg_paren.match?(/<arg_paren <args_add_block <args .+> false>>/)
-          patterns << TOneArgMethodCallParensPattern.new(call.range.begin..arg_paren.range.end)
+          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)>>/) &&
+        if call.match?(/\A<call <var_ref <@const T>> <@period \.> <@ident (?:assert_type!|cast|let)>>\z/) &&
           arg_paren.match?(/<arg_paren <args_add_block <args .+> false>>/)
-          patterns << TTwoArgMethodCallParensPattern.new(call.range.begin..arg_paren.range.end)
+          patterns <<
+            TTwoArgMethodCallParensPattern.new(
+              call.range.begin...arg_paren.range.end,
+              comma: arg_paren.body[0].body[0].body[0].range.end - call.range.begin
+            )
         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)
+          patterns <<
+            TTwoArgMethodCallParensPattern.new(
+              call.range.begin...arg_paren.range.end,
+              comma: arg_paren.body[0].body[0].body[0].range.end - call.range.begin
+            )
         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)
+        # abstract!
+        # final!
+        # interface!
+        if call.match?(/<fcall <@ident (?:abstract|final|interface)!>>/) &&
+          arg_paren.match?("<args >")
+          patterns << DeclarationPattern.new(call.range.begin...arg_paren.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)
+        # mixes_in_class_methods(foo)
+        if call.match?("<fcall <@ident mixes_in_class_methods>>") &&
+          arg_paren.match?(/<arg_paren <args_add_block <args <.+>>> false>>/)
+          patterns << MixesInClassMethodsPattern.new(call.range.begin...arg_paren.range.end)
         end
 
         super
       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\s*)(.+)/) do
-            "#{" " * $1.length}#{$2}"
+          segment.gsub(/(T\s*\.(?:must|reveal_type|unsafe)\s*)(.+)/) do
+            "#{blank($1)}#{$2}"
           end
         end
       end
@@ -141,10 +151,12 @@ module Sorbet
       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>") &&
+          # T.reveal_type foo
+          # T.unsafe foo
+          if ident.match?(/<@ident (?:must|reveal_type|unsafe)>/) &&
             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)
+            patterns << TMustNoParensPattern.new(var_ref.range.begin...args_add_block.range.end)
           end
         end
 
@@ -154,8 +166,8 @@ module Sorbet
       # sig { foo } =>
       class SigBracesPattern < Pattern
         def replace(segment)
-          segment.gsub(/(sig\s*\{.+\})(.*)/) do
-            "#{" " * $1.length}#{$2}"
+          segment.gsub(/(sig\s*\{.+\})(.*)/m) do
+            "#{blank($1)}#{$2}"
           end
         end
       end

data/lib/sorbet/eraser/version.rb

@@ -2,6 +2,6 @@
 
 module Sorbet
   module Eraser
-    VERSION = "0.1.0"
+    VERSION = "0.1.1"
   end
 end

data/lib/sorbet/eraser.rb

@@ -5,17 +5,10 @@ require "ripper"
 require "sorbet/eraser/parser"
 require "sorbet/eraser/patterns"
 require "sorbet/eraser/version"
+require "t"
 
 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)

data/lib/t/enum.rb

@@ -0,0 +1,252 @@
+# frozen_string_literal: true
+
+module T
+  # This is mostly copy-pasted from sorbet-runtime since we have to maintain the
+  # same behavior.
+  class T::Enum
+    ## Enum class methods ##
+
+    def self.values
+      if @values.nil?
+        raise "Attempting to access values of #{self.class} before it has been initialized." \
+          " Enums are not initialized until the 'enums do' block they are defined in has finished running."
+      end
+      @values
+    end
+
+    # This exists for compatibility with the interface of `Hash` & mostly to support
+    # the HashEachMethods Rubocop.
+    def self.each_value(&blk)
+      if blk
+        values.each(&blk)
+      else
+        values.each
+      end
+    end
+
+    # Convert from serialized value to enum instance
+    def self.try_deserialize(serialized_val)
+      if @mapping.nil?
+        raise "Attempting to access serialization map of #{self.class} before it has been initialized." \
+          " Enums are not initialized until the 'enums do' block they are defined in has finished running."
+      end
+      @mapping[serialized_val]
+    end
+
+    # Convert from serialized value to enum instance.
+    #
+    # @return [self]
+    # @raise [KeyError] if serialized value does not match any instance.
+    def self.from_serialized(serialized_val)
+      res = try_deserialize(serialized_val)
+      if res.nil?
+        raise KeyError.new("Enum #{self} key not found: #{serialized_val.inspect}")
+      end
+      res
+    end
+
+    # Note: It would have been nice to make this method final before people started overriding it.
+    # @return [Boolean] Does the given serialized value correspond with any of this enum's values.
+    def self.has_serialized?(serialized_val)
+      if @mapping.nil?
+        raise "Attempting to access serialization map of #{self.class} before it has been initialized." \
+          " Enums are not initialized until the 'enums do' block they are defined in has finished running."
+      end
+      @mapping.include?(serialized_val)
+    end
+
+    def self.serialize(instance)
+      return nil if instance.nil?
+
+      if self == T::Enum
+        raise "Cannot call T::Enum.serialize directly. You must call on a specific child class."
+      end
+      if instance.class != self
+        raise "Cannot call #serialize on a value that is not an instance of #{self}."
+      end
+      instance.serialize
+    end
+
+    # Note: Failed CriticalMethodsNoRuntimeTypingTest
+    def self.deserialize(mongo_value)
+      if self == T::Enum
+        raise "Cannot call T::Enum.deserialize directly. You must call on a specific child class."
+      end
+      self.from_serialized(mongo_value)
+    end
+
+    ## Enum instance methods ##
+
+    def dup
+      self
+    end
+
+    def clone
+      self
+    end
+
+    def serialize
+      assert_bound!
+      @serialized_val
+    end
+
+    def to_json(*args)
+      serialize.to_json(*args)
+    end
+
+    def to_s
+      inspect
+    end
+
+    def inspect
+      "#<#{self.class.name}::#{@const_name || '__UNINITIALIZED__'}>"
+    end
+
+    def <=>(other)
+      case other
+      when self.class
+        self.serialize <=> other.serialize
+      else
+        nil
+      end
+    end
+
+    # NB: Do not call this method. This exists to allow for a safe migration path in places where enum
+    # values are compared directly against string values.
+    #
+    # Ruby's string has a weird quirk where `'my_string' == obj` calls obj.==('my_string') if obj
+    # responds to the `to_str` method. It does not actually call `to_str` however.
+    #
+    # See https://ruby-doc.org/core-2.4.0/String.html#method-i-3D-3D
+    def to_str
+      msg = 'Implicit conversion of Enum instances to strings is not allowed. Call #serialize instead.'
+      raise NoMethodError.new(msg)
+    end
+
+    def ==(other)
+      case other
+      when String
+        false
+      else
+        super(other)
+      end
+    end
+
+    def ===(other)
+      case other
+      when String
+        false
+      else
+        super(other)
+      end
+    end
+
+    ## Private implementation ##
+
+    def initialize(serialized_val=nil)
+      raise 'T::Enum is abstract' if self.class == T::Enum
+      if !self.class.started_initializing?
+        raise "Must instantiate all enum values of #{self.class} inside 'enums do'."
+      end
+      if self.class.fully_initialized?
+        raise "Cannot instantiate a new enum value of #{self.class} after it has been initialized."
+      end
+
+      serialized_val = serialized_val.frozen? ? serialized_val : serialized_val.dup.freeze
+      @serialized_val = serialized_val
+      @const_name = nil
+      self.class._register_instance(self)
+    end
+
+    private def assert_bound!
+      if @const_name.nil?
+        raise "Attempting to access Enum value on #{self.class} before it has been initialized." \
+          " Enums are not initialized until the 'enums do' block they are defined in has finished running."
+      end
+    end
+
+    def _bind_name(const_name)
+      @const_name = const_name
+      @serialized_val = const_to_serialized_val(const_name) if @serialized_val.nil?
+      freeze
+    end
+
+    private def const_to_serialized_val(const_name)
+      # Historical note: We convert to lowercase names because the majority of existing calls to
+      # `make_accessible` were arrays of lowercase strings. Doing this conversion allowed for the
+      # least amount of repetition in migrated declarations.
+      const_name.to_s.downcase.freeze
+    end
+
+    def self.started_initializing?
+      @started_initializing ||= false
+    end
+
+    def self.fully_initialized?
+      @fully_initialized ||= false
+    end
+
+    # Maintains the order in which values are defined
+    def self._register_instance(instance)
+      @values ||= []
+      @values << instance
+    end
+
+    # Entrypoint for allowing people to register new enum values.
+    # All enum values must be defined within this block.
+    def self.enums(&blk)
+      raise "enums cannot be defined for T::Enum" if self == T::Enum
+      raise "Enum #{self} was already initialized" if @fully_initialized
+      raise "Enum #{self} is still initializing" if @started_initializing
+
+      @started_initializing = true
+
+      @values = nil
+
+      yield
+
+      @mapping = nil
+      @mapping = {}
+
+      # Freeze the Enum class and bind the constant names into each of the instances.
+      self.constants(false).each do |const_name|
+        instance = self.const_get(const_name, false)
+        if !instance.is_a?(self)
+          raise "Invalid constant #{self}::#{const_name} on enum. " \
+            "All constants defined for an enum must be instances itself (e.g. `Foo = new`)."
+        end
+
+        instance._bind_name(const_name)
+        serialized = instance.serialize
+        if @mapping.include?(serialized)
+          raise "Enum values must have unique serializations. Value '#{serialized}' is repeated on #{self}."
+        end
+        @mapping[serialized] = instance
+      end
+      @values.freeze
+      @mapping.freeze
+
+      orphaned_instances = T.must(@values) - @mapping.values
+      if !orphaned_instances.empty?
+        raise "Enum values must be assigned to constants: #{orphaned_instances.map {|v| v.instance_variable_get('@serialized_val')}}"
+      end
+
+      @fully_initialized = true
+    end
+
+    def self.inherited(child_class)
+      super
+
+      raise "Inheriting from children of T::Enum is prohibited" if self != T::Enum
+    end
+
+    # Marshal support
+    def _dump(_level)
+      Marshal.dump(serialize)
+    end
+
+    def self._load(args)
+      deserialize(Marshal.load(args))
+    end
+  end
+end

data/lib/t/struct.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module T
+  # This is a shim for the T::Struct class because since you're actually
+  # inheriting from the class there's not really a way to remove it from the
+  # source.
+  class Struct
+    # include T::Props
+    # include T::Props::Serializable
+    # include T::Props::Constructor
+  end
+end

data/lib/t.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "t/enum"
+require "t/struct"
+
+# For some constructs, it doesn't make as much sense to entirely remove them
+# since they're actually used to change runtime behavior. For example, T.absurd
+# will always raise an error. In this case instead of removing the content, we
+# can just shim it.
+module T
+  # These methods should really not be being called in a loop or any other kind
+  # of hot path, so here we're just going to shim them.
+  module Helpers
+    def abstract!; end
+    def interface!; end
+    def final!; end
+    def sealed!; end
+    def mixes_in_class_methods(*); end
+    def requires_ancestor(*); end
+  end
+
+  # Similar to the Helpers module, these things should only be called a couple
+  # of times, so shimming them here.
+  module Generic
+    include Helpers
+    def type_member(*, **); end
+    def type_template(*, **); end
+  end
+
+  # Keeping this module as a thing so that if there's any kind of weird
+  # reflection going on like is_a?(T::Sig) it will still work.
+  module Sig
+  end
+
+  # Type aliases don't actually do anything, but they are usually assigned to
+  # constants, so in that case we need to return something.
+  def self.type_alias
+    Object.new
+  end
+
+  # Absurd always raises a TypeError within Sorbet, so mirroring that behavior
+  # here when T.absurd is called.
+  def self.absurd(value)
+    raise TypeError, value
+  end
+end

data/sorbet-eraser.gemspec

@@ -1,22 +1,31 @@
 # frozen_string_literal: true
 
-lib = File.expand_path("../lib", __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require "sorbet/eraser/version"
+require_relative "lib/sorbet/eraser/version"
+
+version = Sorbet::Eraser::VERSION
+repository = "https://github.com/kddnewton/sorbet-eraser"
 
 Gem::Specification.new do |spec|
   spec.name          = "sorbet-eraser"
-  spec.version       = Sorbet::Eraser::VERSION
+  spec.version       = 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.homepage      = repository
   spec.license       = "MIT"
 
-  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+  spec.metadata = {
+    "bug_tracker_uri" => "#{repository}/issues",
+    "changelog_uri" => "#{repository}/blob/v#{version}/CHANGELOG.md",
+    "source_code_uri" => repository,
+    "rubygems_mfa_required" => "true"
+  }
+
+  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"]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-eraser
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Kevin Newton
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-08-17 00:00:00.000000000 Z
+date: 2021-11-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -55,11 +55,15 @@ dependencies:
 description:
 email:
 - kddnewton@gmail.com
-executables: []
+executables:
+- sorbet-eraser
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/dependabot.yml"
+- ".github/workflows/main.yml"
 - ".gitignore"
+- CHANGELOG.md
 - Gemfile
 - Gemfile.lock
 - LICENSE
@@ -67,16 +71,25 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- exe/sorbet-eraser
 - lib/sorbet/eraser.rb
 - lib/sorbet/eraser/autoload.rb
+- lib/sorbet/eraser/cli.rb
 - lib/sorbet/eraser/parser.rb
 - lib/sorbet/eraser/patterns.rb
 - lib/sorbet/eraser/version.rb
+- lib/t.rb
+- lib/t/enum.rb
+- lib/t/struct.rb
 - sorbet-eraser.gemspec
 homepage: https://github.com/kddnewton/sorbet-eraser
 licenses:
 - MIT
-metadata: {}
+metadata:
+  bug_tracker_uri: https://github.com/kddnewton/sorbet-eraser/issues
+  changelog_uri: https://github.com/kddnewton/sorbet-eraser/blob/v0.1.1/CHANGELOG.md
+  source_code_uri: https://github.com/kddnewton/sorbet-eraser
+  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
 require_paths: