tapioca 0.16.3 → 0.16.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 61d9bbc2b60ce6dda54eea3d826374ca132938ddcdcc8185a731124bbad31704
-  data.tar.gz: 35aec9d2e19694a7737ff32b7a1d1863b24e255f327d87adbc42e435bcef048c
+  metadata.gz: 8efd13a85ae108c14208f510ff83132f745b956a841afe2dd870ec35f67f19f6
+  data.tar.gz: ef25365cfc4c0b2442e57a9309f9554254f7ba27af19a77e7f187e1e7222fb27
 SHA512:
-  metadata.gz: 0d09845c43897689c8b04ca565d22a9dc817fd8100276624ffc21a83538d3584e70909df6007aee6d360abbd63ff2842132db1346483d1faf9615500e4b3c988
-  data.tar.gz: b6ec214e91ed9b14fea2eefc00e396c4ea45157995dfdc52f98494da9498025bfa033b807324757f877768819e68ff04ff32dd0e10f93642dbb48e89dcd77451
+  metadata.gz: acfd5b028a620f619372ec911269e2c0386c5ab0e4a59d6f2d76718875e7b027518a4334f4eb5df6d5f5c8fc07982456b52c55c026bcb0e9db08a7c24435a7fa
+  data.tar.gz: 40b55848a0aa050064596c194a1c9ead65b1ac45ea34ec14d2dfad1d5fe14c89f97da8a35ad6e02d36ce478cbe9f56928246d15a243b8949ee1a1174a25a95fc

data/README.md

@@ -489,8 +489,7 @@ Options:
                                                                                                    # Default: false
   -q,        [--quiet], [--no-quiet], [--skip-quiet]                                               # Suppresses file creation output
                                                                                                    # Default: false
-  -w,        [--workers=N]                                                                         # Number of parallel workers to use when generating RBIs (default: 2)
-                                                                                                   # Default: 2
+  -w,        [--workers=N]                                                                         # Number of parallel workers to use when generating RBIs (default: auto)
              [--rbi-max-line-length=N]                                                             # Set the max line length of generated RBIs. Signatures longer than the max line length will be wrapped
                                                                                                    # Default: 120
   -e,        [--environment=ENVIRONMENT]                                                           # The Rack/Rails environment to use when generating RBIs
@@ -949,7 +948,7 @@ dsl:
   exclude: []
   verify: false
   quiet: false
-  workers: 2
+  workers: 1
   rbi_max_line_length: 120
   environment: development
   list_compilers: false

data/exe/tapioca

@@ -20,6 +20,11 @@ unless ENV["ENFORCE_TYPECHECKING"] == "1"
   end
 end
 
+unless defined?(Bundler)
+  puts "Warning: You're running tapioca without Bundler. This isn't recommended and may cause issues. " \
+    "Please use the provided binstub through `bin/tapioca` instead."
+end
+
 require_relative "../lib/tapioca/internal"
 
 Tapioca::Cli.start(ARGV)

data/lib/ruby_lsp/tapioca/addon.rb

@@ -0,0 +1,132 @@
+# typed: strict
+# frozen_string_literal: true
+
+RubyLsp::Addon.depend_on_ruby_lsp!(">= 0.22.1", "< 0.23")
+
+begin
+  # The Tapioca add-on depends on the Rails add-on to add a runtime component to the runtime server. We can allow the
+  # add-on to work outside of a Rails context in the future, but that may require Tapioca spawning its own runtime
+  # server
+  require "ruby_lsp/ruby_lsp_rails/runner_client"
+rescue LoadError
+  return
+end
+
+require "zlib"
+
+module RubyLsp
+  module Tapioca
+    class Addon < ::RubyLsp::Addon
+      extend T::Sig
+
+      sig { void }
+      def initialize
+        super
+
+        @global_state = T.let(nil, T.nilable(RubyLsp::GlobalState))
+        @rails_runner_client = T.let(nil, T.nilable(RubyLsp::Rails::RunnerClient))
+        @index = T.let(nil, T.nilable(RubyIndexer::Index))
+        @file_checksums = T.let({}, T::Hash[String, String])
+        @outgoing_queue = T.let(nil, T.nilable(Thread::Queue))
+      end
+
+      sig { override.params(global_state: RubyLsp::GlobalState, outgoing_queue: Thread::Queue).void }
+      def activate(global_state, outgoing_queue)
+        @global_state = global_state
+        return unless @global_state.enabled_feature?(:tapiocaAddon)
+
+        @index = @global_state.index
+        @outgoing_queue = outgoing_queue
+        Thread.new do
+          # Get a handle to the Rails add-on's runtime client. The call to `rails_runner_client` will block this thread
+          # until the server has finished booting, but it will not block the main LSP. This has to happen inside of a
+          # thread
+          addon = T.cast(::RubyLsp::Addon.get("Ruby LSP Rails", ">= 0.3.17", "< 0.4"), ::RubyLsp::Rails::Addon)
+          @rails_runner_client = addon.rails_runner_client
+          @outgoing_queue << Notification.window_log_message("Activating Tapioca add-on v#{version}")
+          @rails_runner_client.register_server_addon(File.expand_path("server_addon.rb", __dir__))
+        rescue IncompatibleApiError
+          # The requested version for the Rails add-on no longer matches. We need to upgrade and fix the breaking
+          # changes
+          @outgoing_queue << Notification.window_log_message(
+            "IncompatibleApiError: Cannot activate Tapioca LSP add-on",
+            type: Constant::MessageType::WARNING,
+          )
+        end
+      end
+
+      sig { override.void }
+      def deactivate
+      end
+
+      sig { override.returns(String) }
+      def name
+        "Tapioca"
+      end
+
+      sig { override.returns(String) }
+      def version
+        "0.1.0"
+      end
+
+      sig { params(changes: T::Array[{ uri: String, type: Integer }]).void }
+      def workspace_did_change_watched_files(changes)
+        return unless T.must(@global_state).enabled_feature?(:tapiocaAddon)
+        return unless @rails_runner_client # Client is not ready
+
+        constants = changes.flat_map do |change|
+          path = URI(change[:uri]).to_standardized_path
+          next if path.end_with?("_test.rb", "_spec.rb")
+          next unless file_updated?(change, path)
+
+          entries = T.must(@index).entries_for(path)
+          next unless entries
+
+          entries.filter_map do |entry|
+            entry.name if entry.class == RubyIndexer::Entry::Class || entry.class == RubyIndexer::Entry::Module
+          end
+        end.compact
+
+        return if constants.empty?
+
+        @rails_runner_client.trigger_reload
+        @rails_runner_client.delegate_notification(
+          server_addon_name: "Tapioca",
+          request_name: "dsl",
+          constants: constants,
+        )
+      end
+
+      private
+
+      sig { params(change: T::Hash[Symbol, T.untyped], path: String).returns(T::Boolean) }
+      def file_updated?(change, path)
+        case change[:type]
+        when Constant::FileChangeType::CREATED
+          @file_checksums[path] = Zlib.crc32(File.read(path)).to_s
+          return true
+        when Constant::FileChangeType::CHANGED
+          current_checksum = Zlib.crc32(File.read(path)).to_s
+          if @file_checksums[path] == current_checksum
+            T.must(@outgoing_queue) << Notification.window_log_message(
+              "File has not changed. Skipping #{path}",
+              type: Constant::MessageType::INFO,
+            )
+          else
+            @file_checksums[path] = current_checksum
+            return true
+          end
+        when Constant::FileChangeType::DELETED
+          @file_checksums.delete(path)
+        else
+          T.must(@outgoing_queue) << Notification.window_log_message(
+            "Unexpected file change type: #{change[:type]}",
+            type: Constant::MessageType::WARNING,
+          )
+        end
+
+        false
+      end
+    end
+  end
+end

data/lib/ruby_lsp/tapioca/server_addon.rb

@@ -0,0 +1,30 @@
+# typed: false
+# frozen_string_literal: true
+
+require "tapioca/internal"
+
+module RubyLsp
+  module Tapioca
+    class ServerAddon < ::RubyLsp::Rails::ServerAddon
+      def name
+        "Tapioca"
+      end
+
+      def execute(request, params)
+        case request
+        when "dsl"
+          fork do
+            dsl(params)
+          end
+        end
+      end
+
+      private
+
+      def dsl(params)
+        load("tapioca/cli.rb") # Reload the CLI to reset thor defaults between requests
+        ::Tapioca::Cli.start(["dsl", "--lsp_addon", "--workers=1"] + params[:constants])
+      end
+    end
+  end
+end

data/lib/tapioca/cli.rb

@@ -111,8 +111,7 @@ module Tapioca
     option :workers,
       aliases: ["-w"],
       type: :numeric,
-      desc: "Number of parallel workers to use when generating RBIs (default: 2)",
-      default: 2
+      desc: "Number of parallel workers to use when generating RBIs (default: auto)"
     option :rbi_max_line_length,
       type: :numeric,
       desc: "Set the max line length of generated RBIs. Signatures longer than the max line length will be wrapped",
@@ -144,6 +143,11 @@ module Tapioca
       type: :hash,
       desc: "Options to pass to the DSL compilers",
       default: {}
+    option :lsp_addon,
+      type: :boolean,
+      desc: "Generate DSL RBIs from the LSP addon. Internal to tapioca and not intended for end-users",
+      default: false,
+      hide: true
     def dsl(*constant_or_paths)
       set_environment(options)
 
@@ -166,6 +170,7 @@ module Tapioca
         app_root: options[:app_root],
         halt_upon_load_error: options[:halt_upon_load_error],
         compiler_options: options[:compiler_options],
+        lsp_addon: options[:lsp_addon],
       }
 
       command = if options[:verify]

data/lib/tapioca/commands/abstract_dsl.rb

@@ -28,6 +28,7 @@ module Tapioca
           app_root: String,
           halt_upon_load_error: T::Boolean,
           compiler_options: T::Hash[String, T.untyped],
+          lsp_addon: T::Boolean,
         ).void
       end
       def initialize(
@@ -47,7 +48,8 @@ module Tapioca
         rbi_formatter: DEFAULT_RBI_FORMATTER,
         app_root: ".",
         halt_upon_load_error: true,
-        compiler_options: {}
+        compiler_options: {},
+        lsp_addon: false
       )
         @requested_constants = requested_constants
         @requested_paths = requested_paths
@@ -66,6 +68,7 @@ module Tapioca
         @halt_upon_load_error = halt_upon_load_error
         @skip_constant = skip_constant
         @compiler_options = compiler_options
+        @lsp_addon = lsp_addon
 
         super()
       end
@@ -74,6 +77,10 @@ module Tapioca
 
       sig { params(outpath: Pathname, quiet: T::Boolean).returns(T::Set[Pathname]) }
       def generate_dsl_rbi_files(outpath, quiet:)
+        if @lsp_addon
+          pipeline.active_compilers.each(&:reset_state)
+        end
+
         existing_rbi_files = existing_rbi_filenames(all_requested_constants)
 
         generated_files = pipeline.run do |constant, contents|
@@ -116,6 +123,7 @@ module Tapioca
           eager_load: @requested_constants.empty? && @requested_paths.empty?,
           app_root: @app_root,
           halt_upon_load_error: @halt_upon_load_error,
+          lsp_addon: @lsp_addon,
         )
       end
 
@@ -133,6 +141,7 @@ module Tapioca
           skipped_constants: constantize(@skip_constant, ignore_missing: true),
           number_of_workers: @number_of_workers,
           compiler_options: @compiler_options,
+          lsp_addon: @lsp_addon,
         )
       end
 
@@ -170,7 +179,9 @@ module Tapioca
           raise Thor::Error, ""
         end
 
-        processable_constants.map { |_, constant| constant }
+        processable_constants
+          .map { |_, constant| constant }
+          .grep(Module)
       end
 
       sig { params(compiler_names: T::Array[String]).returns(T::Array[T.class_of(Tapioca::Dsl::Compiler)]) }

data/lib/tapioca/commands/dsl_generate.rb

@@ -19,7 +19,7 @@ module Tapioca
         purge_stale_dsl_rbi_files(rbi_files_to_purge)
         say("Done", :green)
 
-        if @auto_strictness
+        if @auto_strictness && !@lsp_addon
           say("")
           validate_rbi_files(
             command: default_command(:dsl, all_requested_constants.join(" ")),

data/lib/tapioca/dsl/compiler.rb

@@ -51,6 +51,13 @@ module Tapioca
           @@requested_constants = constants # rubocop:disable Style/ClassVars
         end
 
+        sig { void }
+        def reset_state
+          @processable_constants = nil
+          @all_classes = nil
+          @all_modules = nil
+        end
+
         private
 
         sig do
@@ -74,11 +81,7 @@ module Tapioca
         sig { returns(T::Enumerable[T::Class[T.anything]]) }
         def all_classes
           @all_classes ||= T.let(
-            if @@requested_constants.any?
-              @@requested_constants.grep(Class)
-            else
-              ObjectSpace.each_object(Class)
-            end,
+            all_modules.grep(Class).freeze,
             T.nilable(T::Enumerable[T::Class[T.anything]]),
           )
         end
@@ -87,10 +90,10 @@ module Tapioca
         def all_modules
           @all_modules ||= T.let(
             if @@requested_constants.any?
-              @@requested_constants.select { |k| k.is_a?(Module) }
+              @@requested_constants.grep(Module)
             else
-              ObjectSpace.each_object(Module)
-            end,
+              ObjectSpace.each_object(Module).to_a
+            end.freeze,
             T.nilable(T::Enumerable[Module]),
           )
         end

data/lib/tapioca/dsl/compilers/aasm.rb

@@ -69,6 +69,17 @@ module Tapioca
             T::Array[String],
           )
 
+        TRANSITION_CALLBACKS =
+          T.let(
+            [
+              "on_transition",
+              "guard",
+              "after",
+              "success",
+            ].freeze,
+            T::Array[String],
+          )
+
         ConstantType = type_member { { fixed: T.all(T::Class[::AASM], ::AASM::ClassMethods) } }
 
         sig { override.void }
@@ -162,8 +173,37 @@ module Tapioca
                     method,
                     parameters: [
                       create_opt_param("symbol", type: "T.nilable(Symbol)", default: "nil"),
-                      create_block_param("block", type: "T.nilable(T.proc.bind(#{constant_name}).void)"),
+                      create_block_param(
+                        "block",
+                        type: "T.nilable(T.proc.bind(#{constant_name}).params(opts: T.untyped).void)",
+                      ),
+                    ],
+                  )
+                end
+
+                event.create_method(
+                  "transitions",
+                  parameters: [
+                    create_opt_param("definitions", default: "nil", type: "T.untyped"),
+                    create_block_param("block", type: "T.nilable(T.proc.bind(PrivateAASMTransition).void)"),
+                  ],
+                )
+              end
+
+              machine.create_class("PrivateAASMTransition", superclass_name: "AASM::Core::Transition") do |transition|
+                TRANSITION_CALLBACKS.each do |method|
+                  return_type = "T.untyped"
+                  return_type = "T::Boolean" if method == "guard"
+
+                  transition.create_method(
+                    method,
+                    parameters: [
+                      create_block_param(
+                        "block",
+                        type: "T.nilable(T.proc.bind(#{constant_name}).params(opts: T.untyped).void)",
+                      ),
                     ],
+                    return_type: return_type,
                   )
                 end
               end

data/lib/tapioca/dsl/compilers/active_record_relations.rb

@@ -210,10 +210,6 @@ module Tapioca
             query_methods |= ActiveRecord::SpawnMethods.instance_methods(false)
             # Remove the ones we know are private API
             query_methods -= [:all, :arel, :build_subquery, :construct_join_dependency, :extensions, :spawn]
-            # Remove "group" which needs a custom return type for GroupChains
-            query_methods -= [:group]
-            # Remove "where" which needs a custom return type for WhereChains
-            query_methods -= [:where]
             # Remove the methods that ...
             query_methods
               .grep_v(/_clause$/) # end with "_clause"
@@ -419,7 +415,7 @@ module Tapioca
 
         sig { void }
         def create_relation_where_chain_class
-          model.create_class(RelationWhereChainClassName, superclass_name: RelationClassName) do |klass|
+          model.create_class(RelationWhereChainClassName) do |klass|
             create_where_chain_methods(klass, RelationClassName)
             klass.create_type_variable("Elem", type: "type_member", fixed: constant_name)
           end
@@ -427,10 +423,7 @@ module Tapioca
 
         sig { void }
         def create_association_relation_where_chain_class
-          model.create_class(
-            AssociationRelationWhereChainClassName,
-            superclass_name: AssociationRelationClassName,
-          ) do |klass|
+          model.create_class(AssociationRelationWhereChainClassName) do |klass|
             create_where_chain_methods(klass, AssociationRelationClassName)
             klass.create_type_variable("Elem", type: "type_member", fixed: constant_name)
           end
@@ -560,27 +553,21 @@ module Tapioca
         sig { void }
         def create_relation_methods
           create_relation_method("all")
-          create_relation_method(
-            "group",
-            parameters: [
-              create_rest_param("args", type: "T.untyped"),
-              create_block_param("blk", type: "T.untyped"),
-            ],
-            relation_return_type: RelationGroupChainClassName,
-            association_return_type: AssociationRelationGroupChainClassName,
-          )
-          create_relation_method(
-            "where",
-            parameters: [
-              create_rest_param("args", type: "T.untyped"),
-              create_block_param("blk", type: "T.untyped"),
-            ],
-            relation_return_type: RelationWhereChainClassName,
-            association_return_type: AssociationRelationWhereChainClassName,
-          )
 
           QUERY_METHODS.each do |method_name|
             case method_name
+            when :where
+              create_where_relation_method
+            when :group
+              create_relation_method(
+                "group",
+                parameters: [
+                  create_rest_param("args", type: "T.untyped"),
+                  create_block_param("blk", type: "T.untyped"),
+                ],
+                relation_return_type: RelationGroupChainClassName,
+                association_return_type: AssociationRelationGroupChainClassName,
+              )
             when :distinct
               create_relation_method(
                 method_name.to_s,
@@ -1056,6 +1043,35 @@ module Tapioca
           )
         end
 
+        sig { void }
+        def create_where_relation_method
+          relation_methods_module.create_method("where") do |method|
+            method.add_rest_param("args")
+
+            method.add_sig do |sig|
+              sig.return_type = RelationWhereChainClassName
+            end
+
+            method.add_sig do |sig|
+              sig.add_param("args", "T.untyped")
+              sig.return_type = RelationClassName
+            end
+          end
+
+          association_relation_methods_module.create_method("where") do |method|
+            method.add_rest_param("args")
+
+            method.add_sig do |sig|
+              sig.return_type = AssociationRelationWhereChainClassName
+            end
+
+            method.add_sig do |sig|
+              sig.add_param("args", "T.untyped")
+              sig.return_type = AssociationRelationClassName
+            end
+          end
+        end
+
         sig do
           params(
             name: T.any(Symbol, String),

data/lib/tapioca/dsl/pipeline.rb

@@ -34,6 +34,7 @@ module Tapioca
           skipped_constants: T::Array[Module],
           number_of_workers: T.nilable(Integer),
           compiler_options: T::Hash[String, T.untyped],
+          lsp_addon: T::Boolean,
         ).void
       end
       def initialize(
@@ -44,7 +45,8 @@ module Tapioca
         error_handler: $stderr.method(:puts).to_proc,
         skipped_constants: [],
         number_of_workers: nil,
-        compiler_options: {}
+        compiler_options: {},
+        lsp_addon: false
       )
         @active_compilers = T.let(
           gather_active_compilers(requested_compilers, excluded_compilers),
@@ -56,6 +58,7 @@ module Tapioca
         @skipped_constants = skipped_constants
         @number_of_workers = number_of_workers
         @compiler_options = compiler_options
+        @lsp_addon = lsp_addon
         @errors = T.let([], T::Array[String])
       end
 
@@ -177,7 +180,7 @@ module Tapioca
         # Find the constants that have been reloaded
         reloaded_constants = constants_by_name.select { |_, constants| constants.size > 1 }.keys
 
-        unless reloaded_constants.empty?
+        unless reloaded_constants.empty? || @lsp_addon
           reloaded_constant_names = reloaded_constants.map { |name| "`#{name}`" }.join(", ")
 
           $stderr.puts("WARNING: Multiple constants with the same name: #{reloaded_constant_names}")
@@ -222,9 +225,14 @@ module Tapioca
 
       sig { void }
       def abort_if_pending_migrations!
+        # When running within the add-on, we cannot invoke the abort if pending migrations task because that will exit
+        # the process and crash the Rails runtime server. Instead, the Rails add-on checks for pending migrations and
+        # warns the user, so that they are aware they need to migrate their database
+        return if @lsp_addon
         return unless defined?(::Rake)
 
         Rails.application.load_tasks
+
         if Rake::Task.task_defined?("db:abort_if_pending_migrations")
           Rake::Task["db:abort_if_pending_migrations"].invoke
         end

data/lib/tapioca/helpers/git_attributes.rb

@@ -28,7 +28,8 @@ class GitAttributes
       # exist, we just return.
       return unless path.exist?
 
-      File.write(path.join(".gitattributes"), content)
+      git_attributes_path = path.join(".gitattributes")
+      File.write(git_attributes_path, content) unless git_attributes_path.exist?
     end
   end
 end

data/lib/tapioca/helpers/rbi_helper.rb

@@ -107,36 +107,12 @@ module Tapioca
 
     sig { params(name: String).returns(T::Boolean) }
     def valid_method_name?(name)
-      # try to parse a method definition with this name
-      iseq = RubyVM::InstructionSequence.compile("def #{name}; end", nil, nil, 0, false)
-      # pull out the first operation in the instruction sequence and its first argument
-      op, arg, _data = iseq.to_a.dig(-1, 0)
-      # make sure that the operation is a method definition and the method that was
-      # defined has the expected name, for example, for `def !foo; end` we don't get
-      # a syntax error but instead get a method defined as `"foo"`
-      op == :definemethod && arg == name.to_sym
-    rescue SyntaxError
-      false
+      Prism.parse_success?("def self.#{name}(a); end")
     end
 
     sig { params(name: String).returns(T::Boolean) }
     def valid_parameter_name?(name)
-      sentinel_method_name = :sentinel_method_name
-      # try to parse a method definition with this name as the name of a
-      # keyword parameter. If we use a positional parameter, then parameter names
-      # like `&` (and maybe others) will be treated like `def foo(&); end` and will
-      # thus be considered valid. Using a required keyword parameter prevents that
-      # confusion between Ruby syntax and parameter name.
-      iseq = RubyVM::InstructionSequence.compile("def #{sentinel_method_name}(#{name}:); end", nil, nil, 0, false)
-      # pull out the first operation in the instruction sequence and its first argument and data
-      op, arg, data = iseq.to_a.dig(-1, 0)
-      # make sure that:
-      # 1. a method was defined, and
-      # 2. the method has the expected method name, and
-      # 3. the method has a keyword parameter with the expected name
-      op == :definemethod && arg == sentinel_method_name && data.dig(11, :keyword, 0) == name.to_sym
-    rescue SyntaxError
-      false
+      Prism.parse_success?("def sentinel_method_name(#{name}:); end")
     end
   end
 end

data/lib/tapioca/helpers/source_uri.rb

@@ -25,9 +25,6 @@ module URI
     # have the uri gem in their own bundle and thus not use a compatible version.
     PARSER = T.let(const_defined?(:RFC2396_PARSER) ? RFC2396_PARSER : DEFAULT_PARSER, RFC2396_Parser)
 
-    alias_method(:gem_name, :host)
-    alias_method(:line_number, :fragment)
-
     sig { returns(T.nilable(String)) }
     attr_reader :gem_version
 
@@ -54,6 +51,16 @@ module URI
       end
     end
 
+    sig { returns(T.nilable(String)) }
+    def gem_name
+      host
+    end
+
+    sig { returns(T.nilable(String)) }
+    def line_number
+      fragment
+    end
+
     sig { params(v: T.nilable(String)).void }
     def set_path(v) # rubocop:disable Naming/AccessorMethodName
       return if v.nil?

data/lib/tapioca/internal.rb

@@ -23,6 +23,7 @@ require "tempfile"
 require "thor"
 require "yaml"
 require "yard-sorbet"
+require "prism"
 
 require "tapioca/runtime/dynamic_mixin_compiler"
 require "tapioca/sorbet_ext/backcompat_patches"

data/lib/tapioca/loaders/dsl.rb

@@ -10,16 +10,32 @@ module Tapioca
         extend T::Sig
 
         sig do
-          params(tapioca_path: String, eager_load: T::Boolean, app_root: String, halt_upon_load_error: T::Boolean).void
+          params(
+            tapioca_path: String,
+            eager_load: T::Boolean,
+            app_root: String,
+            halt_upon_load_error: T::Boolean,
+            lsp_addon: T::Boolean,
+          ).void
         end
-        def load_application(tapioca_path:, eager_load: true, app_root: ".", halt_upon_load_error: true)
+        def load_application(
+          tapioca_path:,
+          eager_load: true,
+          app_root: ".",
+          halt_upon_load_error: true,
+          lsp_addon: false
+        )
           loader = new(
             tapioca_path: tapioca_path,
             eager_load: eager_load,
             app_root: app_root,
             halt_upon_load_error: halt_upon_load_error,
           )
-          loader.load
+          if lsp_addon
+            loader.load_dsl_extensions_and_compilers
+          else
+            loader.load
+          end
         end
       end
 
@@ -30,6 +46,12 @@ module Tapioca
         load_dsl_compilers
       end
 
+      sig { void }
+      def load_dsl_extensions_and_compilers
+        load_dsl_extensions
+        load_dsl_compilers
+      end
+
       protected
 
       sig do
@@ -63,12 +85,7 @@ module Tapioca
       def load_dsl_compilers
         say("Loading DSL compiler classes... ")
 
-        # Load all built-in compilers
-        Dir.glob("#{Tapioca::LIB_ROOT_DIR}/tapioca/dsl/compilers/*.rb").each do |compiler|
-          require File.expand_path(compiler)
-        end
-
-        # Load all custom compilers exported from gems
+        # Load built-in compilers and custom compilers exported from gems
         ::Gem.find_files("tapioca/dsl/compilers/*.rb").each do |compiler|
           require File.expand_path(compiler)
         end

data/lib/tapioca/runtime/reflection.rb

@@ -178,13 +178,19 @@ module Tapioca
       end
 
       # Examines the call stack to identify the closest location where a "require" is performed
-      # by searching for the label "<top (required)>". If none is found, it returns the location
+      # by searching for the label "<top (required)>" or "block in <class:...>" in the
+      # case of an ActiveSupport.on_load hook. If none is found, it returns the location
       # labeled "<main>", which is the original call site.
       sig { params(locations: T.nilable(T::Array[Thread::Backtrace::Location])).returns(String) }
       def resolve_loc(locations)
         return "" unless locations
 
-        resolved_loc = locations.find { |loc| REQUIRED_FROM_LABELS.include?(loc.label) }
+        resolved_loc = locations.find do |loc|
+          label = loc.label
+          next unless label
+
+          REQUIRED_FROM_LABELS.include?(label) || label.start_with?("block in <class:")
+        end
         return "" unless resolved_loc
 
         resolved_loc.absolute_path || ""

data/lib/tapioca/static/symbol_loader.rb

@@ -51,6 +51,8 @@ module Tapioca
 
         sig { params(paths: T::Array[Pathname]).returns(T::Set[String]) }
         def symbols_from_paths(paths)
+          return Set.new if paths.empty?
+
           output = Tempfile.create("sorbet") do |file|
             file.write(Array(paths).join("\n"))
             file.flush

data/lib/tapioca/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Tapioca
-  VERSION = "0.16.3"
+  VERSION = "0.16.5"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tapioca
 version: !ruby/object:Gem::Version
-  version: 0.16.3
+  version: 0.16.5
 platform: ruby
 authors:
 - Ufuk Kayserilioglu
@@ -11,7 +11,7 @@ authors:
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-10-03 00:00:00.000000000 Z
+date: 2024-11-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -136,6 +136,8 @@ files:
 - LICENSE.txt
 - README.md
 - exe/tapioca
+- lib/ruby_lsp/tapioca/addon.rb
+- lib/ruby_lsp/tapioca/server_addon.rb
 - lib/tapioca.rb
 - lib/tapioca/bundler_ext/auto_require_hook.rb
 - lib/tapioca/cli.rb
@@ -284,7 +286,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.20
+rubygems_version: 3.5.23
 signing_key:
 specification_version: 4
 summary: A Ruby Interface file generator for gems, core types and the Ruby standard