tapioca 0.19.2 → 0.20.0

data/lib/tapioca/gem/listeners/methods.rb

@@ -69,6 +69,7 @@ module Tapioca
 
           begin
             signature = signature_of!(method)
+            signature ||= inferred_attr_writer_signature(method, constant)
             method = signature.method if signature #: UnboundMethod
 
             case @pipeline.method_definition_in_gem(method.name, constant)
@@ -101,7 +102,7 @@ module Tapioca
           sanitized_parameters = parameters.each_with_index.map do |(type, name), index|
             fallback_arg_name = "_arg#{index}"
 
-            name = if name
+            sig_name = if name
               name.to_s
             else
               # For attr_writer methods, Sorbet signatures have the name
@@ -125,10 +126,14 @@ module Tapioca
               end
             end
 
-            # Sanitize param names
-            name = fallback_arg_name unless valid_parameter_name?(name)
+            # Sanitize param names, except for anonymous splat, keyword splat,
+            # and block parameters. Ruby reflects those as `:*`, `:**`, and `:&`,
+            # and Sorbet signatures use the same names to store their types.
+            is_anonymous_parameter = anonymous_parameter_name?(type, sig_name)
+            sig_name = fallback_arg_name unless is_anonymous_parameter || valid_parameter_name?(sig_name)
+            param_name = is_anonymous_parameter ? nil : sig_name
 
-            [type, name]
+            [type, param_name, sig_name]
           end
 
           rbi_method = RBI::Method.new(
@@ -137,26 +142,27 @@ module Tapioca
             visibility: visibility,
           )
 
-          sanitized_parameters.each do |type, name|
+          sanitized_parameters.each do |type, param_name, _sig_name|
             case type
             when :req
-              rbi_method << RBI::ReqParam.new(name)
+              rbi_method << RBI::ReqParam.new(param_name)
             when :opt
-              rbi_method << RBI::OptParam.new(name, "T.unsafe(nil)")
+              rbi_method << RBI::OptParam.new(param_name, "T.unsafe(nil)")
             when :rest
-              rbi_method << RBI::RestParam.new(name)
+              rbi_method << RBI::RestParam.new(param_name)
             when :keyreq
-              rbi_method << RBI::KwParam.new(name)
+              rbi_method << RBI::KwParam.new(param_name)
             when :key
-              rbi_method << RBI::KwOptParam.new(name, "T.unsafe(nil)")
+              rbi_method << RBI::KwOptParam.new(param_name, "T.unsafe(nil)")
             when :keyrest
-              rbi_method << RBI::KwRestParam.new(name)
+              rbi_method << RBI::KwRestParam.new(param_name)
             when :block
-              rbi_method << RBI::BlockParam.new(name)
+              rbi_method << RBI::BlockParam.new(param_name)
             end
           end
 
-          @pipeline.push_method(symbol_name, constant, method, rbi_method, signature, sanitized_parameters)
+          parameters_for_signature = sanitized_parameters.map { |type, _param_name, sig_name| [type, sig_name] }
+          @pipeline.push_method(symbol_name, constant, method, rbi_method, signature, parameters_for_signature)
           tree << rbi_method
         end
 
@@ -192,6 +198,66 @@ module Tapioca
           }
         end
 
+        #: (UnboundMethod method, Module[top] constant) -> untyped
+        def inferred_attr_writer_signature(method, constant)
+          reader_method = attr_reader_for_writer(method, constant)
+          return unless reader_method
+
+          reader_signature = signature_of(reader_method)
+          return unless reader_signature
+
+          build_attr_writer_signature(method, reader_method, reader_signature)
+        end
+
+        #: (UnboundMethod method, Module[top] constant) -> UnboundMethod?
+        def attr_reader_for_writer(method, constant)
+          method_name = method.name.to_s
+          return unless method_name.end_with?("=")
+          return unless method.parameters == [[:req]]
+
+          reader_method = T.let(constant.instance_method(method_name.delete_suffix("=").to_sym), UnboundMethod)
+          reader_method = original_method(reader_method)
+          return unless same_source_location?(method, reader_method)
+          return unless method_owned_by_constant?(reader_method, constant)
+
+          reader_method
+        rescue NameError
+          nil
+        end
+
+        #: (UnboundMethod writer_method, UnboundMethod reader_method, untyped reader_signature) -> untyped
+        def build_attr_writer_signature(writer_method, reader_method, reader_signature)
+          return unless reader_signature.arg_types.empty?
+          return unless reader_signature.kwarg_types.empty?
+          return if reader_signature.rest_type
+          return if reader_signature.keyrest_type
+          return if reader_signature.block_type
+
+          T::Private::Methods::Signature.new(
+            method: writer_method,
+            method_name: writer_method.name,
+            raw_arg_types: { reader_method.name => reader_signature.return_type },
+            raw_return_type: reader_signature.return_type,
+            bind: nil,
+            mode: reader_signature.mode,
+            check_level: reader_signature.check_level,
+            on_failure: reader_signature.on_failure,
+            override_allow_incompatible: reader_signature.override_allow_incompatible,
+            defined_raw: reader_signature.defined_raw,
+          )
+        end
+
+        #: (UnboundMethod method) -> UnboundMethod
+        def original_method(method)
+          T.let(signature_of(method)&.method || method, UnboundMethod)
+        end
+
+        #: (UnboundMethod method, UnboundMethod other_method) -> bool
+        def same_source_location?(method, other_method)
+          source_location = method.source_location
+          !!source_location && source_location == other_method.source_location
+        end
+
         #: (Module[top] constant, String method_name) -> bool
         def struct_method?(constant, method_name)
           return false unless T::Props::ClassMethods === constant

data/lib/tapioca/gem/listeners/sorbet_enums.rb

@@ -11,7 +11,7 @@ module Tapioca
         #: (ScopeNodeAdded event) -> void
         def on_scope(event)
           constant = event.constant
-          return unless T::Enum > event.constant # rubocop:disable Style/InvertibleUnlessCondition
+          return unless T::Enum > event.constant
 
           enum_block = RBI::TEnumBlock.new
 

data/lib/tapioca/gem/pipeline.rb

@@ -7,7 +7,7 @@ module Tapioca
       include Runtime::Reflection
       include RBIHelper
 
-      IGNORED_SYMBOLS = ["YAML", "MiniTest", "Mutex"] #: Array[String]
+      IGNORED_SYMBOLS = ["YAML", "MiniTest", "Mutex"].freeze #: Array[String]
 
       #: Gemfile::GemSpec
       attr_reader :gem
@@ -100,7 +100,7 @@ module Tapioca
       #|   untyped signature,
       #|   Array[[Symbol, String]] parameters
       #| ) -> void
-      def push_method(symbol, constant, method, node, signature, parameters) # rubocop:disable Metrics/ParameterLists
+      def push_method(symbol, constant, method, node, signature, parameters)
         @events << Gem::MethodNodeAdded.new(symbol, constant, method, node, signature, parameters)
       end
 
@@ -356,7 +356,7 @@ module Tapioca
 
       #: (Class[top] constant) -> String?
       def compile_superclass(constant)
-        superclass = nil #: Class[top]? # rubocop:disable Lint/UselessAssignment
+        superclass = nil #: Class[top]?
 
         while (superclass = superclass_of(constant))
           constant_name = name_of(constant)

data/lib/tapioca/gemfile.rb

@@ -48,8 +48,21 @@ module Tapioca
       end
     end
 
+    #: (String path) -> bool
+    def excluded_gem_path?(path)
+      excluded_gem_specs.any? { |spec| spec.contains_path?(path) }
+    end
+
     private
 
+    #: -> Array[GemSpec]
+    def excluded_gem_specs
+      @excluded_gem_specs ||= @excluded_gems.filter_map do |name|
+        spec = ::Gem.loaded_specs[name]
+        GemSpec.new(spec) if spec
+      end #: Array[GemSpec]?
+    end
+
     #: File
     attr_reader(:gemfile, :lockfile)
 

data/lib/tapioca/helpers/env_helper.rb

@@ -5,7 +5,7 @@ module Tapioca
   # @requires_ancestor: Thor
   module EnvHelper
     #: (Hash[Symbol, untyped] options) -> void
-    def set_environment(options) # rubocop:disable Naming/AccessorMethodName
+    def set_environment(options)
       ENV["RAILS_ENV"] = ENV["RACK_ENV"] = options[:environment]
       ENV["RUBY_DEBUG_LAZY"] = "1"
     end

data/lib/tapioca/helpers/file_helper.rb

@@ -0,0 +1,42 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "open3"
+
+module Tapioca
+  module FileHelper
+    #: (Pathname filename, Pathname | String old_path, Pathname | String new_path) -> String?
+    def file_diff(filename, old_path, new_path)
+      filename = filename.to_s
+      stdout, stderr, status = Open3.capture3(
+        "diff",
+        "-u",
+        "--label=Current #{filename}",
+        old_path.to_s,
+        "--label=Expected #{filename} (After running `bin/tapioca dsl`)",
+        new_path.to_s,
+      )
+
+      unless [0, 1].include?(status.exitstatus)
+        error_msg("Failed to create #{filename} diff. #{stderr.chomp}")
+        return
+      end
+
+      stdout
+    rescue SystemCallError => e
+      error_msg("Failed to create #{filename} diff. #{e.message}")
+      nil
+    end
+
+    private
+
+    RED = "\e[31m" #: String
+    CLEAR = "\e[0m" #: String
+
+    #: (String message) -> void
+    def error_msg(message)
+      message = "#{RED}#{message}#{CLEAR}"
+      Kernel.warn(message)
+    end
+  end
+end

data/lib/tapioca/helpers/rbi_files_helper.rb

@@ -78,7 +78,7 @@ module Tapioca
       res = sorbet(
         "--no-config",
         "--error-url-base=#{error_url_base}",
-        "--stop-after namer",
+        "--stop-after resolver",
         dsl_dir,
         gem_dir,
       )
@@ -129,12 +129,16 @@ module Tapioca
         ERR
       end
 
-      if auto_strictness
-        redef_errors = errors.select { |error| error.code == 4010 }
-        update_gem_rbis_strictnesses(redef_errors, gem_dir)
-      end
+      handled_errors = apply_validation_fixes(errors, gem_dir: gem_dir, auto_strictness: auto_strictness)
 
       Kernel.raise Tapioca::Error, error_messages.join("\n") if parse_errors.any?
+
+      unhandled_errors = errors - handled_errors
+      unhandled_errors.reject! { |error| ignored_validation_error?(error, gem_dir: gem_dir, dsl_dir: dsl_dir) }
+
+      if unhandled_errors.empty?
+        say("  No errors found\n\n", [:green, :bold])
+      end
     end
 
     private
@@ -258,6 +262,93 @@ module Tapioca
       )
     end
 
+    SUPPRESS_PAYLOAD_SUPERCLASS_REDEFINITION_FLAG =
+      "--suppress-payload-superclass-redefinition-for" #: String
+
+    #: (Array[Spoom::Sorbet::Errors::Error] errors) -> void
+    def update_sorbet_config_for_payload_superclass_redefinitions(errors)
+      errors
+        .filter_map { |error| payload_superclass_constant_from_error(error) }
+        .uniq
+        .each { |constant| add_payload_superclass_suppression_to_config(constant) }
+    end
+
+    #: (Spoom::Sorbet::Errors::Error error) -> String?
+    def payload_superclass_constant_from_error(error)
+      error.more.each do |line|
+        if line =~ /--suppress-payload-superclass-redefinition-for=([^\s`]+)/
+          return T.must(Regexp.last_match(1))
+        end
+      end
+
+      nil
+    end
+
+    #: (
+    #|   Array[Spoom::Sorbet::Errors::Error] errors,
+    #|   gem_dir: String,
+    #|   auto_strictness: bool,
+    #| ) -> Array[Spoom::Sorbet::Errors::Error]
+    def apply_validation_fixes(errors, gem_dir:, auto_strictness:)
+      handled_errors = [] #: Array[Spoom::Sorbet::Errors::Error]
+
+      if auto_strictness
+        redef_errors = errors.select { |error| error.code == 4010 }
+        update_gem_rbis_strictnesses(redef_errors, gem_dir) if redef_errors.any?
+        handled_errors.concat(redef_errors)
+      end
+
+      # Automatically fix payload superclass redefinition errors.
+      payload_superclass_errors = errors.select { |error| payload_superclass_error?(error) }
+      if payload_superclass_errors.any?
+        update_sorbet_config_for_payload_superclass_redefinitions(payload_superclass_errors)
+      end
+      handled_errors.concat(payload_superclass_errors)
+
+      handled_errors
+    end
+
+    #: (Spoom::Sorbet::Errors::Error error) -> bool
+    def payload_superclass_error?(error)
+      error.more.any? { |line| line.include?(SUPPRESS_PAYLOAD_SUPERCLASS_REDEFINITION_FLAG) }
+    end
+
+    #: (Spoom::Sorbet::Errors::Error error, gem_dir: String, dsl_dir: String) -> bool
+    def ignored_validation_error?(error, gem_dir:, dsl_dir:)
+      return false if Dir.exist?(gem_dir) && !Dir.glob("#{gem_dir}/**/*.rbi").empty?
+
+      [5002, 5067].include?(error.code) && T.must(error.file).start_with?(dsl_dir)
+    end
+
+    #: (String constant) -> void
+    def add_payload_superclass_suppression_to_config(constant)
+      flag = "#{SUPPRESS_PAYLOAD_SUPERCLASS_REDEFINITION_FLAG}=#{constant}"
+      config_path = Tapioca::SORBET_CONFIG_FILE
+      config = File.exist?(config_path) ? File.read(config_path) : ""
+      flag_already_present = config.lines(chomp: true).include?(flag)
+
+      if flag_already_present
+        say(
+          "\n  Payload superclass of `#{constant}` was redefined; `#{flag}` is already in sorbet/config\n",
+          [:yellow, :bold],
+        )
+        return
+      end
+
+      FileUtils.mkdir_p(File.dirname(config_path))
+      if config.empty?
+        File.write(config_path, "#{flag}\n")
+      else
+        suffix = config.end_with?("\n") ? "" : "\n"
+        File.write(config_path, "#{config}#{suffix}#{flag}\n")
+      end
+      say(
+        "\n  Added `#{flag}` to sorbet/config (payload superclass of `#{constant}` was redefined)",
+        [:yellow, :bold],
+      )
+      say("\n")
+    end
+
     #: (Array[Spoom::Sorbet::Errors::Error] errors, String gem_dir) -> void
     def update_gem_rbis_strictnesses(errors, gem_dir)
       files = []

data/lib/tapioca/helpers/rbi_helper.rb

@@ -37,7 +37,7 @@ module Tapioca
       create_typed_param(RBI::OptParam.new(name, default), type)
     end
 
-    #: (String name, type: String) -> RBI::TypedParam
+    #: (String? name, type: String) -> RBI::TypedParam
     def create_rest_param(name, type:)
       create_typed_param(RBI::RestParam.new(name), type)
     end
@@ -52,12 +52,12 @@ module Tapioca
       create_typed_param(RBI::KwOptParam.new(name, default), type)
     end
 
-    #: (String name, type: String) -> RBI::TypedParam
+    #: (String? name, type: String) -> RBI::TypedParam
     def create_kw_rest_param(name, type:)
       create_typed_param(RBI::KwRestParam.new(name), type)
     end
 
-    #: (String name, type: String) -> RBI::TypedParam
+    #: (String? name, type: String) -> RBI::TypedParam
     def create_block_param(name, type:)
       create_typed_param(RBI::BlockParam.new(name), type)
     end
@@ -110,5 +110,19 @@ module Tapioca
     def valid_parameter_name?(name)
       Prism.parse_success?("def sentinel_method_name(#{name}:); end")
     end
+
+    #: (Symbol type, String name) -> bool
+    def anonymous_parameter_name?(type, name)
+      case type
+      when :rest
+        name == "*"
+      when :keyrest
+        name == "**"
+      when :block
+        name == "&"
+      else
+        false
+      end
+    end
   end
 end

data/lib/tapioca/helpers/sorbet_helper.rb

@@ -24,7 +24,7 @@ module Tapioca
 
     #: (String, rbi_mode: bool) { (String stderr) -> void } -> void
     def sorbet_syntax_check!(source, rbi_mode:, &on_failure)
-      quoted_source = "\"#{source}\""
+      quoted_source = source.shellescape
 
       result = if rbi_mode
         # --e-rbi cannot be used on its own, so we pass a dummy value like `-e ""`

data/lib/tapioca/internal.rb

@@ -54,6 +54,7 @@ require "tapioca/helpers/rbi_helper"
 require "tapioca/helpers/package_url"
 require "tapioca/helpers/cli_helper"
 require "tapioca/helpers/config_helper"
+require "tapioca/helpers/file_helper"
 require "tapioca/helpers/rbi_files_helper"
 require "tapioca/helpers/env_helper"
 

data/lib/tapioca/loaders/gem.rb

@@ -49,6 +49,39 @@ module Tapioca
         @halt_upon_load_error = halt_upon_load_error
       end
 
+      #: -> void
+      def load_gem_extensions
+        say("Loading gem extension classes... ")
+
+        # Extensions are loaded before the bundle is required so that they can patch the gems
+        # they apply to as those gems are being loaded.
+        Dir.glob("#{Tapioca::TAPIOCA_DIR}/gem/extensions/**/*.rb").each do |extension|
+          require File.expand_path(extension)
+        end
+
+        ::Gem.find_files("tapioca/gem/extensions/*.rb").each do |extension|
+          next if @bundle.excluded_gem_path?(extension)
+
+          require File.expand_path(extension)
+        end
+
+        say("Done", :green)
+      end
+
+      #: (Tapioca::Gemfile gemfile, String? initialize_file, String? require_file, bool halt_upon_load_error) -> void
+      def load_bundle(gemfile, initialize_file, require_file, halt_upon_load_error)
+        require_helper(initialize_file)
+        load_gem_extensions
+
+        load_rails_application(halt_upon_load_error: halt_upon_load_error)
+
+        gemfile.require_bundle
+
+        require_helper(require_file)
+
+        load_rails_engines
+      end
+
       #: -> void
       def require_gem_file
         say("Requiring all gems to prepare for compiling... ")

data/lib/tapioca/loaders/loader.rb

@@ -15,19 +15,6 @@ module Tapioca
 
       private
 
-      #: (Tapioca::Gemfile gemfile, String? initialize_file, String? require_file, bool halt_upon_load_error) -> void
-      def load_bundle(gemfile, initialize_file, require_file, halt_upon_load_error)
-        require_helper(initialize_file)
-
-        load_rails_application(halt_upon_load_error: halt_upon_load_error)
-
-        gemfile.require_bundle
-
-        require_helper(require_file)
-
-        load_rails_engines
-      end
-
       #: (?environment_load: bool, ?eager_load: bool, ?app_root: String, ?halt_upon_load_error: bool) -> void
       def load_rails_application(environment_load: false, eager_load: false, app_root: ".", halt_upon_load_error: true)
         return unless File.exist?(File.expand_path("config/application.rb", app_root))

data/lib/tapioca/rbi_ext/model.rb

@@ -76,11 +76,10 @@ module RBI
       if !block || !parameters.empty? || return_type
         # If there is no block, and the params and return type have not been supplied, then
         # we create a single signature with the given parameters and return type
-        params = parameters.map { |param| RBI::SigParam.new(param.param.name.to_s, param.type) }
         return_type ||= "T.untyped"
         type_params = Tapioca::RBIHelper.extract_type_parameters(parameters.map(&:type).append(return_type))
 
-        sig = RBI::Sig.new(params: params, return_type: return_type, type_params: type_params)
+        sig = RBI::Sig.new(params: parameters.map(&:to_sig_param), return_type: return_type, type_params: type_params)
         sigs << sig
       end
 
@@ -117,5 +116,20 @@ module RBI
   class TypedParam < T::Struct
     const :param, RBI::Param
     const :type, String
+
+    #: -> RBI::SigParam
+    def to_sig_param
+      name = case param
+      when RestParam
+        param.anonymous? ? "*".inspect : param.name.to_s
+      when KwRestParam
+        param.anonymous? ? "**".inspect : param.name.to_s
+      when BlockParam
+        param.anonymous? ? "&".inspect : param.name.to_s
+      else
+        param.name.to_s
+      end
+      RBI::SigParam.new(name, type)
+    end
   end
 end

data/lib/tapioca/rbs/bootsnap_cache.rb

@@ -0,0 +1,52 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "bundler"
+require "digest"
+require "fileutils"
+
+module Tapioca
+  module RBS
+    # Prepares the Bootsnap iseq cache used for RBS rewrite output.
+    #
+    # RBS rewrite output can change when the lockfile changes, even if the
+    # source files are unchanged.
+    # To account for this, we store the current Gemfile.lock SHA256 in a
+    # `.gemfile-lock-digest` file.
+    # A digest mismatch deletes Bootsnap's cache payload and records the new
+    # digest, so this run rebuilds the cache from scratch.
+    module BootsnapCache
+      DIGEST_FILE = ".gemfile-lock-digest" #: String
+
+      class << self
+        #: (String) -> void
+        def prepare_for_setup(cache_dir)
+          digest = gemfile_lock_digest
+          return if digest_matches?(cache_dir, digest)
+
+          FileUtils.rm_rf(File.join(cache_dir, "bootsnap"))
+          FileUtils.mkdir_p(cache_dir)
+          File.write(digest_path(cache_dir), digest)
+        end
+
+        private
+
+        #: -> String
+        def gemfile_lock_digest
+          Digest::SHA256.file(Bundler.default_lockfile).hexdigest
+        end
+
+        #: (String, String) -> bool
+        def digest_matches?(cache_dir, digest)
+          path = digest_path(cache_dir)
+          File.file?(path) && File.read(path).chomp == digest
+        end
+
+        #: (String) -> String
+        def digest_path(cache_dir)
+          File.join(cache_dir, DIGEST_FILE)
+        end
+      end
+    end
+  end
+end

data/lib/tapioca/rbs/rewriter.rb

@@ -29,32 +29,43 @@ module Tapioca
         MSG
       end
     end
+
+    module BootsnapIntegration
+      class << self
+        extend T::Sig
+
+        sig { void }
+        def setup
+          require "bootsnap"
+          require "tapioca/rbs/bootsnap_cache"
+
+          cache_dir = ENV.fetch("TAPIOCA_BOOTSNAP_CACHE_DIR", File.join(Dir.pwd, "tmp/cache/bootsnap-tapioca-rbs"))
+          Tapioca::RBS::BootsnapCache.prepare_for_setup(cache_dir)
+
+          Bootsnap.setup(
+            cache_dir: cache_dir,
+            development_mode: true,
+            load_path_cache: true,
+            compile_cache_iseq: true,
+            compile_cache_yaml: true,
+            readonly: false,
+            revalidation: true,
+          )
+          Bootsnap.log_stats!
+
+          Bootsnap.singleton_class.prepend(Tapioca::RBS::BootsnapGuard)
+        end
+      end
+    end
   end
 end
 
-# When TAPIOCA_RBS_CACHE=1, set up bootsnap with a dedicated cache directory
-# and load require-hooks so the RBS-rewritten iseqs get cached. Subsequent
-# runs read the rewritten iseq directly and skip the rewrite.
-#
-# After our setup, BootsnapGuard is prepended so the host application can't
-# replace our cache directory.
+# When TAPIOCA_RBS_CACHE=1, use a dedicated Bootsnap cache directory for
+# RBS-rewritten iseqs. After setup, BootsnapGuard is prepended so the host
+# application cannot replace Tapioca's cache directory.
 if ENV["TAPIOCA_RBS_CACHE"] == "1"
   begin
-    require "bootsnap"
-    # Respect BOOTSNAP_READONLY for consumers reading a pre-populated cache
-    # (e.g. a CI prime step).
-    readonly = !["0", "false", false].include?(ENV.fetch("BOOTSNAP_READONLY") { false })
-    Bootsnap.setup(
-      cache_dir: ENV.fetch("TAPIOCA_BOOTSNAP_CACHE_DIR", File.join(Dir.pwd, "tmp/cache/bootsnap-tapioca-rbs")),
-      development_mode: true,
-      load_path_cache: true,
-      compile_cache_iseq: true,
-      compile_cache_yaml: true,
-      readonly: readonly,
-      revalidation: true,
-    )
-    Bootsnap.log_stats!
-    Bootsnap.singleton_class.prepend(Tapioca::RBS::BootsnapGuard)
+    Tapioca::RBS::BootsnapIntegration.setup
   rescue LoadError
     # Bootsnap is not in the bundle, skip iseq caching.
   end

data/lib/tapioca/runtime/dynamic_mixin_compiler.rb

@@ -53,7 +53,7 @@ module Tapioca
                 mixins_from_modules[mod] = (after - before).reverse!
               end
             end
-          rescue Exception # rubocop:disable Lint/RescueException
+          rescue Exception
             # this is a best effort, bail if we can't perform this
           end
 
@@ -85,7 +85,6 @@ module Tapioca
             super(*attrs, **kwargs) if defined?(super)
           end
 
-          # rubocop:disable Style/MissingRespondToMissing
           T::Sig::WithoutRuntime.sig { params(symbol: Symbol, args: T.untyped).returns(T.untyped) }
           def method_missing(symbol, *args)
             # We need this here so that we can handle any random instance