sorbet-eraser 0.2.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: efd5822039bf577e0c4a37171d7e91abd9c7bed250c9d09c779f52faa0d84cf6
-  data.tar.gz: 1a88eab81b0932ab400f5aeaf08e43cb5107fc08c135e232cc444205f76fdcf3
+  metadata.gz: cbfc0c7e028bd4e712e64d29a7c74e65d45937087a3f510f01afab434250b3d5
+  data.tar.gz: 6a89286f19c7ae6ed8e838beba49fcb799426fb14a58ed4b5c3b32d9b59935dc
 SHA512:
-  metadata.gz: a64889bcbdf6affe397a394ed3a0841a166ff376e806e050967d4676910670a5f75d774e25c2490fae410c2b5e9263f07c07597ae6c0a0c08ae226343032ed0f
-  data.tar.gz: 50b223fde3f5901535888d6e06f685ba128c6bda051d516fe37f8b825ce9c328bfddaff54bb19a52aa1694309be11a74732ceb0b582e00179cf939d8eba760ba
+  metadata.gz: efe378c67fa4749ac7461496d895c69e89ef28ca1f71d6c9385952a96320e8849a6ed15604d8219560903d047b0f9a1eda60fb938b07dc633f55da95a1082119
+  data.tar.gz: af3a02739fbbfdec2fd98c1bbb749b74a2a7f088c237f339966b186ad4b565e8cd353bac2bd4989f2fba8ae7435a096a058c4aca5cded0f209113826e284e994

data/CHANGELOG.md

@@ -6,11 +6,35 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) a
 
 ## [Unreleased]
 
+## [0.3.1] - 2023-06-27
+
+### Added
+
+- Shims for `T::Configuration`, `T::Private::RuntimeLevels`, and `T::Methods`.
+
+### Changed
+
+- Fixed various parsing bugs due to incorrect location.
+
+## [0.3.0] - 2023-06-27
+
+### Added
+
+- Support for the `default` and `without_accessors` options for `T::Struct`.
+
+## [0.2.0] - 2023-06-26
+
+### Added
+
+- Better support for `T::Struct` subclasses.
+
 ## [0.1.1] - 2021-11-17
 
 ### Changed
 
 - Require MFA for releasing.
 
-[unreleased]: https://github.com/kddnewton/sorbet-eraser/compare/v0.1.1...HEAD
+[unreleased]: https://github.com/kddnewton/sorbet-eraser/compare/v0.3.0...HEAD
+[0.3.0]: https://github.com/kddnewton/sorbet-eraser/compare/v0.2.0...v0.3.0
+[0.2.0]: https://github.com/kddnewton/sorbet-eraser/compare/v0.1.1...v0.2.0
 [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.2.0)
+    sorbet-eraser (0.3.1)
 
 GEM
   remote: https://rubygems.org/
@@ -10,6 +10,7 @@ GEM
     rake (13.0.6)
 
 PLATFORMS
+  arm64-darwin-21
   arm64-darwin-22
   x86_64-darwin-19
   x86_64-darwin-21
@@ -22,4 +23,4 @@ DEPENDENCIES
   sorbet-eraser!
 
 BUNDLED WITH
-   2.2.15
+   2.4.12

data/README.md

@@ -5,9 +5,37 @@
 
 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.
+[Sorbet](https://sorbet.org/) is a type checker for Ruby. To annotate types in your Ruby code, you use constructs like `sig` and `T.let`. Sorbet then uses a static analysis tool to check that your code is type safe. At runtime, these types are enforced by the `sorbet-runtime` gem that provides implementations of all of these constructs.
 
-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.
+Sometimes, you want to use Sorbet for development, but don't want to run `sorbet-runtime` in production. This may be because you have a performance-critical application, or because you're writing a library and you don't want to impose a runtime dependency on your users.
+
+To handle these use cases, `sorbet-eraser` provides a way to erase all traces of `sorbet-runtime` code from your source code. This means that you can use Sorbet for development, but not have to worry about `sorbet-runtime` in production. For example,
+
+```ruby
+class HelloWorld
+  extend T::Sig
+
+  sig { returns(String) }
+  def hello
+    T.let("World!", String)
+  end
+end
+```
+
+will be transformed into
+
+```ruby
+class HelloWorld
+               
+
+                         
+  def hello
+          "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.
 
 ## Installation
 
@@ -27,17 +55,37 @@ Or install it yourself as:
 
 ## Usage
 
-There are two ways to use this gem, depending on your needs.
+There are two ways to use this gem, depending on your needs. You can erase `sorbet-runtime` code ahead of time or just in time.
 
-The first is that you can hook into the Ruby compilation process and do just-in-time erasure. To do this — 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. This eliminates the need for a build step, but slows down your parse/boot time.
+### Ahead of time
 
-The second is that you can preprocess your Ruby files using either the CLI or the Ruby API. With the CLI, you would run:
+To erase `sorbet-runtime` code ahead of time, you would either use the CLI provided with this gem or the Ruby API. With the CLI, you would run:
 
 ```bash
 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.  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.
+It accepts any number of filepaths/patterns on the command line and will modify the source files in place with their erased contents. If you would instead prefer to script it yourself using the Ruby API, you would run:
+
+```ruby
+Sorbet::Eraser.erase(source)
+```
+
+where `source` is a string that represents valid Ruby code.
+
+### Just in time
+
+If you're looking to avoid a build step like the one described above, you can instead erase your code immediately before it is compiled by the Ruby virtual machine. To do, call:
+
+```ruby
+require "sorbet/eraser/autoload"
+```
+
+as soon as possible when your application is first booting. This will hook into the autoload process to erase all `sorbet-runtime` code before it gets passed to Ruby to parse. Note that the tradeoff here is that it eliminates the need for a build step, but slows down your parse/boot time.
+
+### Runtime structures
+
+If you used any runtime structures like `T::Struct` or `T::Enum` you'll need a runtime shim. We provide very basic versions of these in the `sorbet-eraser` gem, and they are required automatically.
 
 ### Status
 

data/lib/sorbet/eraser/parser.rb

@@ -59,7 +59,10 @@ module Sorbet
         end
 
         def to_s
-          @to_s ||= "<#{event} #{body.map(&:to_s).join(" ")}>"
+          @repr ||= begin
+            children = body.map { |child| child.is_a?(Array) ? child.map(&:to_s) : child }
+            "<#{event} #{children.join(" ")}>"
+          end
         end
       end
 
@@ -67,7 +70,7 @@ module Sorbet
       class ParsingError < StandardError
       end
 
-      attr_reader :source, :line_counts, :errors, :patterns
+      attr_reader :source, :line_counts, :errors, :patterns, :heredocs
 
       def initialize(source)
         super(source)
@@ -88,6 +91,7 @@ module Sorbet
 
         @errors = []
         @patterns = []
+        @heredocs = []
       end
 
       def self.erase(source)
@@ -108,11 +112,146 @@ module Sorbet
         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.size) }
+        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.size) }
+        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&.size || 0)) }
+          range = loc.then { |start| start...(start + (value&.size || 0)) }
           Node.new(:"@#{event}", [value], range)
         end
       end
@@ -122,41 +261,33 @@ 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|
+        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, [], loc.then { |start| start..start })
+            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.begin..value.range.end)
+                node.range || value.range
               end
 
             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)
-
-            first ||= loc.then { |start| start..start }
-            last ||= first
-
-            Node.new(event, args, first.begin..[last.end, loc].max)
+            Node.new(event, args, find_loc(args))
           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

@@ -101,69 +101,80 @@ module Sorbet
       end
 
       def on_method_add_arg(call, arg_paren)
-        # T.must(foo)
-        # T.reveal_type(foo)
-        # 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>>/)
+        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)
-        end
-
-        # T.assert_type!(foo, bar)
-        # T.cast(foo, bar)
-        # T.let(foo, bar)
-        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,
-              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,
-              comma: arg_paren.body[0].body[0].body[0].range.end - call.range.begin
-            )
-        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
-
-        # mixes_in_class_methods(foo)
-        if call.match?("<fcall <@ident mixes_in_class_methods>>") &&
-          arg_paren.match?(/<arg_paren <args_add_block <args <.+>>> false>>/)
+        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
-      # const :foo, String
-      class PropPattern < Pattern
+      # prop :foo, String => prop :foo
+      # const :foo, String => const :foo
+      class PropWithoutOptionsPattern < Pattern
         def replace(segment)
-          segment.gsub(/((?:prop|const)\s+:.+),(\s*)([^\n;,]+)(.*)/m) do
-            "#{$1} #{$2}#{blank($3)}#{$4}"
+          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?(/<@ident (?:const|prop)>/)
-          # prop :foo, String
-          # const :foo, String
-          if args_add_block.match?(/<args_add_block <args <symbol_literal <symbol <@ident .+>>> <.+> false>/)
-            patterns << PropPattern.new(ident.range.begin...args_add_block.range.end)
+        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
 
@@ -171,15 +182,11 @@ module Sorbet
       end
 
       def on_command_call(var_ref, period, ident, args_add_block)
-        if var_ref.match?("<var_ref <@const T>>") && period.match?("<@period .>")
+        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
-          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)
-          end
+          patterns << TMustNoParensPattern.new(var_ref.range.begin..args_add_block.range.end)
         end
 
         super
@@ -194,10 +201,22 @@ module Sorbet
         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)
-        # sig { foo }
-        if value.match?(/<method_add_block <method_add_arg <fcall <@ident sig>> <args >> <brace_block  <stmts .+>>>/)
+        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

data/lib/sorbet/eraser/version.rb

@@ -2,6 +2,6 @@
 
 module Sorbet
   module Eraser
-    VERSION = "0.2.0"
+    VERSION = "0.3.1"
   end
 end

data/lib/t/props.rb

@@ -20,31 +20,31 @@ module T
       end
 
       def prop(name, rules = {})
-        create_prop(name)
-        attr_accessor name
+        create_prop(name, rules)
+        attr_accessor(name) unless rules[:without_accessors]
       end
 
       def const(name, rules = {})
-        create_prop(name)
-        attr_reader name
+        create_prop(name, rules)
+        attr_reader(name) unless rules[:without_accessors]
       end
 
       private
 
-      def create_prop(name)
-        props << name
-        props.sort!
+      def create_prop(name, rules)
+        props << [name, rules]
+        props.sort_by!(&:first)
       end
     end
 
     # Here we're going to check against the props that have been defined on the
     # class level and set appropriate values.
     def initialize(hash = {})
-      if self.class.props == hash.keys.sort
-        hash.each { |key, value| instance_variable_set("@#{key}", value) }
-      else
-        raise ArgumentError, "Expected keys #{self.class.props} but got #{hash.keys.sort}"
+      self.class.props.each do |name, rules|
+        instance_variable_set("@#{name}", hash.key?(name) ? hash.delete(name) : rules[:default])
       end
+
+      raise ArgumentError, "unknown keyword: #{hash.keys.first}" unless hash.empty?
     end
 
     # This module is entirely empty because we haven't implemented anything from

data/lib/t.rb

@@ -33,6 +33,34 @@ module T
   module Sig
   end
 
+  # I really don't want to be shimming this, but there are places where people
+  # try to reference these values.
+  module Private
+    module RuntimeLevels
+      def self.default_checked_level; :never; end
+    end
+  
+    module Methods
+      module MethodHooks
+      end
+
+      module SingletonMethodHooks
+      end
+
+      def self.signature_for_method(method); method; end
+    end
+  end
+
+  # I also don't want to shim this, but there are places where people will
+  # reference it.
+  module Configuration
+    class << self
+      attr_accessor :inline_type_error_handler,
+                    :call_validation_error_handler,
+                    :sig_builder_error_handler
+    end
+  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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-eraser
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Kevin Newton
@@ -88,7 +88,7 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/kddnewton/sorbet-eraser/issues
-  changelog_uri: https://github.com/kddnewton/sorbet-eraser/blob/v0.2.0/CHANGELOG.md
+  changelog_uri: https://github.com/kddnewton/sorbet-eraser/blob/v0.3.1/CHANGELOG.md
   source_code_uri: https://github.com/kddnewton/sorbet-eraser
   rubygems_mfa_required: 'true'
 post_install_message: