sorbet-eraser 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5ddbc396f3f164a3d0e67e9cf7046733ce52f792eb0abc17e9f5f056f415cd5e
-  data.tar.gz: 965ef9955b75bba0a2702ea127d5923d7e4b1a55ed2b2e6dca239970adbb0fe1
+  metadata.gz: 3859ee512cb01ed5b84df15af3dedaa629c30d122e80a7436821841f87184562
+  data.tar.gz: 8392610b8fb03ea78d2572b684c2ccf9b4806f082043e3b2614550a370eeea13
 SHA512:
-  metadata.gz: 5deb006431e8e31ed089fe6e8fba281f3c65487fc6996a853b05bb0d9600ff034232e7319fb44912a69dc89b60b160900b9b503a17991d19da2bf02f5803c5f8
-  data.tar.gz: a6a20f8aa21b2a2c9e75a4c7e83db5b28556516296d16f55eedd0113da807cbf0c3a827fbeda7eaf9fb95d2a29a9f0c4ddc9090d638e00469989520d2c492f1d
+  metadata.gz: 02ee32fc8bcf3d1951ddd9577a4f46c181a01f196eb6c2af34bb8bb0b68a0ebc3fb28515d0ca1e391d2d1ee305d3012aafd943918df643dd2a3a44c5272a38b2
+  data.tar.gz: fa7b5e80e3fda49d50df015532110f6b4050450c5348f4d9f0ac6f40c8e2b411882a5348b38e305419b74e0bf6e833b887997bb6757e440fb3acc552e286d7e4

data/CHANGELOG.md

@@ -6,6 +6,23 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) a
 
 ## [Unreleased]
 
+## [0.4.0] - 2023-07-03
+
+### Added
+
+- `require "t"` now requires a file that only requires `"sorbet/eraser/t"`, so they are effectively the same thing. If you're in a situation where you need to load a different `"t"`, then you can manually require `"sorbet/eraser/t"` and it should work.
+- Replace all `typed:` comments with `typed: ignore`.
+
+## [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
@@ -24,7 +41,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.3.0...HEAD
+[unreleased]: https://github.com/kddnewton/sorbet-eraser/compare/v0.4.0...HEAD
+[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
 [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.3.0)
+    sorbet-eraser (0.4.0)
 
 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,41 @@
 
 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
+# typed: true
+
+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,47 +59,66 @@ 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. For that, you can add `require "t"` to your codebase, which ships with this gem, or in your gemfile `gem "sorbet-eraser", require: "t"`.
+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
 
 Below is a table of the status of each `sorbet-runtime` construct and its current support status.
 
-| 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::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`                                      | ✅     | `# 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`             |
 
 In the above table, for `Status`:
 

data/lib/sorbet/eraser/parser.rb

@@ -70,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)
@@ -86,11 +86,12 @@ module Sorbet
             @line_counts << MultiByteString.new(last_index, line)
           end
 
-          last_index += line.size
+          last_index += line.bytesize
         end
 
         @errors = []
         @patterns = []
+        @heredocs = []
       end
 
       def self.erase(source)
@@ -133,15 +134,6 @@ module Sorbet
         end
       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
-
       # Better location information for aref.
       def on_aref(recv, arg)
         rend = arg.range.end + source[arg.range.end..].index("]") + 1
@@ -150,23 +142,90 @@ module Sorbet
 
       # Better location information for arg_paren.
       def on_arg_paren(arg)
-        rbegin = source[..arg.range.begin].rindex("(")
-        rend = arg.range.end + source[arg.range.end..].index(")") + 1
-        Node.new(:arg_paren, [arg], rbegin...rend)
+        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)
-        rbegin = source[...(params || body).range.begin].rindex("{")
-        rend = body.range.end + source[body.range.end..].index("}") + 1
-        Node.new(:brace_block, [params, body], rbegin...rend)
+        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)
-        rbegin = source[...(params || body).range.begin].rindex("do")
-        rend = body.range.end + source[body.range.end..].index("end") + 3
-        Node.new(:do_block, [params, body], rbegin...rend)
+        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.
@@ -174,12 +233,33 @@ module Sorbet
         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.
-      handled = private_instance_methods(false)
-
       PARSER_EVENT_TABLE.each do |event, arity|
         next if handled.include?(:"on_#{event}")
 
@@ -194,8 +274,10 @@ module Sorbet
             range =
               if node.body.empty?
                 value.range
-              else
+              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)

data/lib/sorbet/eraser/patterns.rb

@@ -100,13 +100,37 @@ module Sorbet
         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?(/<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)
-        elsif 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>>/)
+        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)
@@ -114,18 +138,18 @@ module Sorbet
             call.range.begin...arg_paren.range.end,
             comma: arg_paren.body[0].body[0].body[0].range.end - call.range.begin
           )
-        elsif call.match?(/<call <var_ref <@const T>> <@period \.> <@ident bind>>/) && arg_paren.match?(/<arg_paren <args_add_block <args <var_ref <@kw self>> .+> false>>/)
+        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?(/<fcall <@ident (?:abstract|final|interface)!>>/) && arg_paren.match?("<args >")
+        elsif call.match?(/\A<fcall <@ident (?:abstract|final|interface)!>>\z/) && arg_paren.match?("<args >")
           # abstract!
           # final!
           # interface!
-          patterns << DeclarationPattern.new(call.range.begin...arg_paren.range.end)
-        elsif call.match?("<fcall <@ident mixes_in_class_methods>>") && arg_paren.match?(/<arg_paren <args_add_block <args <.+>>> false>>/)
+          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
@@ -159,8 +183,8 @@ module Sorbet
       end
 
       def on_command(ident, args_add_block)
-        if ident.match?(/<@ident (?:const|prop)>/)
-          if args_add_block.match?(/<args_add_block <args <symbol_literal <symbol <@ident .+?>>> <.+> <bare_assoc_hash .+> false>/)
+        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(
@@ -168,7 +192,7 @@ module Sorbet
               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?(/<args_add_block <args <symbol_literal <symbol <@ident .+?>>> <.+> false>/)
+          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(
@@ -182,7 +206,7 @@ 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 .>") && ident.match?(/<@ident (?:must|reveal_type|unsafe)>/) && args_add_block.match?(/<args_add_block <args <.+>> false>/) && args_add_block.body[0].body.length == 1
+        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
@@ -211,10 +235,10 @@ module Sorbet
       end
 
       def on_stmts_add(node, value)
-        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?(/<method_add_block <method_add_arg <fcall <@ident sig>> <args >> <do_block  <bodystmt .+>>>/)
+        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

data/lib/{t → sorbet/eraser/t}/props.rb

@@ -41,13 +41,7 @@ module T
     # class level and set appropriate values.
     def initialize(hash = {})
       self.class.props.each do |name, rules|
-        if hash.key?(name)
-          instance_variable_set("@#{name}", hash.delete(name))
-        elsif rules.key?(:default)
-          instance_variable_set("@#{name}", rules[:default])
-        else
-          raise ArgumentError, "missing keyword: #{name}"
-        end
+        instance_variable_set("@#{name}", hash.key?(name) ? hash.delete(name) : rules[:default])
       end
 
       raise ArgumentError, "unknown keyword: #{hash.keys.first}" unless hash.empty?

data/lib/sorbet/eraser/t.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "sorbet/eraser/t/enum"
+require "sorbet/eraser/t/props"
+require "sorbet/eraser/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
+
+  # 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
+    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/lib/sorbet/eraser/version.rb

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

data/lib/t.rb

@@ -1,47 +1,3 @@
 # frozen_string_literal: true
 
-require "t/enum"
-require "t/props"
-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
+require "sorbet/eraser/t"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-eraser
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Kevin Newton
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-06-27 00:00:00.000000000 Z
+date: 2023-07-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -77,18 +77,19 @@ files:
 - 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
+- lib/sorbet/eraser/t/struct.rb
 - lib/sorbet/eraser/version.rb
 - lib/t.rb
-- lib/t/enum.rb
-- lib/t/props.rb
-- lib/t/struct.rb
 - sorbet-eraser.gemspec
 homepage: https://github.com/kddnewton/sorbet-eraser
 licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/kddnewton/sorbet-eraser/issues
-  changelog_uri: https://github.com/kddnewton/sorbet-eraser/blob/v0.3.0/CHANGELOG.md
+  changelog_uri: https://github.com/kddnewton/sorbet-eraser/blob/v0.4.0/CHANGELOG.md
   source_code_uri: https://github.com/kddnewton/sorbet-eraser
   rubygems_mfa_required: 'true'
 post_install_message: