sorbet-eraser 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5ddbc396f3f164a3d0e67e9cf7046733ce52f792eb0abc17e9f5f056f415cd5e
-  data.tar.gz: 965ef9955b75bba0a2702ea127d5923d7e4b1a55ed2b2e6dca239970adbb0fe1
+  metadata.gz: cbfc0c7e028bd4e712e64d29a7c74e65d45937087a3f510f01afab434250b3d5
+  data.tar.gz: 6a89286f19c7ae6ed8e838beba49fcb799426fb14a58ed4b5c3b32d9b59935dc
 SHA512:
-  metadata.gz: 5deb006431e8e31ed089fe6e8fba281f3c65487fc6996a853b05bb0d9600ff034232e7319fb44912a69dc89b60b160900b9b503a17991d19da2bf02f5803c5f8
-  data.tar.gz: a6a20f8aa21b2a2c9e75a4c7e83db5b28556516296d16f55eedd0113da807cbf0c3a827fbeda7eaf9fb95d2a29a9f0c4ddc9090d638e00469989520d2c492f1d
+  metadata.gz: efe378c67fa4749ac7461496d895c69e89ef28ca1f71d6c9385952a96320e8849a6ed15604d8219560903d047b0f9a1eda60fb938b07dc633f55da95a1082119
+  data.tar.gz: af3a02739fbbfdec2fd98c1bbb749b74a2a7f088c237f339966b186ad4b565e8cd353bac2bd4989f2fba8ae7435a096a058c4aca5cded0f209113826e284e994

data/CHANGELOG.md

@@ -6,6 +6,16 @@ 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

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    sorbet-eraser (0.3.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,19 +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. 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
 

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)
@@ -91,6 +91,7 @@ module Sorbet
 
         @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.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.
@@ -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&.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.
-      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

@@ -101,12 +101,12 @@ module Sorbet
       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 +114,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 +159,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 +168,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 +182,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 +211,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/sorbet/eraser/version.rb

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

data/lib/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/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.3.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.3.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: