solargraph 0.61.0 → 0.62.0

data/lib/solargraph/parser/parser_gem/node_processors.rb

@@ -6,31 +6,34 @@ module Solargraph
   module Parser
     module ParserGem
       module NodeProcessors
-        autoload :BeginNode,     'solargraph/parser/parser_gem/node_processors/begin_node'
-        autoload :DefNode,       'solargraph/parser/parser_gem/node_processors/def_node'
-        autoload :DefsNode,      'solargraph/parser/parser_gem/node_processors/defs_node'
-        autoload :SendNode,      'solargraph/parser/parser_gem/node_processors/send_node'
-        autoload :NamespaceNode, 'solargraph/parser/parser_gem/node_processors/namespace_node'
-        autoload :SclassNode,    'solargraph/parser/parser_gem/node_processors/sclass_node'
-        autoload :IvasgnNode,    'solargraph/parser/parser_gem/node_processors/ivasgn_node'
-        autoload :IfNode,        'solargraph/parser/parser_gem/node_processors/if_node'
-        autoload :CvasgnNode,    'solargraph/parser/parser_gem/node_processors/cvasgn_node'
-        autoload :LvasgnNode,    'solargraph/parser/parser_gem/node_processors/lvasgn_node'
-        autoload :GvasgnNode,    'solargraph/parser/parser_gem/node_processors/gvasgn_node'
-        autoload :CasgnNode,     'solargraph/parser/parser_gem/node_processors/casgn_node'
-        autoload :MasgnNode,     'solargraph/parser/parser_gem/node_processors/masgn_node'
-        autoload :AliasNode,     'solargraph/parser/parser_gem/node_processors/alias_node'
-        autoload :ArgsNode,      'solargraph/parser/parser_gem/node_processors/args_node'
-        autoload :BlockNode,     'solargraph/parser/parser_gem/node_processors/block_node'
-        autoload :OrasgnNode,    'solargraph/parser/parser_gem/node_processors/orasgn_node'
-        autoload :OpasgnNode,    'solargraph/parser/parser_gem/node_processors/opasgn_node'
-        autoload :SymNode,       'solargraph/parser/parser_gem/node_processors/sym_node'
-        autoload :ResbodyNode,   'solargraph/parser/parser_gem/node_processors/resbody_node'
-        autoload :UntilNode,     'solargraph/parser/parser_gem/node_processors/until_node'
-        autoload :WhenNode,      'solargraph/parser/parser_gem/node_processors/when_node'
-        autoload :WhileNode,     'solargraph/parser/parser_gem/node_processors/while_node'
-        autoload :AndNode,       'solargraph/parser/parser_gem/node_processors/and_node'
-        autoload :OrNode,        'solargraph/parser/parser_gem/node_processors/or_node'
+        autoload :BeginNode,        'solargraph/parser/parser_gem/node_processors/begin_node'
+        autoload :DefNode,          'solargraph/parser/parser_gem/node_processors/def_node'
+        autoload :DefsNode,         'solargraph/parser/parser_gem/node_processors/defs_node'
+        autoload :SendNode,         'solargraph/parser/parser_gem/node_processors/send_node'
+        autoload :NamespaceNode,    'solargraph/parser/parser_gem/node_processors/namespace_node'
+        autoload :SclassNode,       'solargraph/parser/parser_gem/node_processors/sclass_node'
+        autoload :IvasgnNode,       'solargraph/parser/parser_gem/node_processors/ivasgn_node'
+        autoload :IfNode,           'solargraph/parser/parser_gem/node_processors/if_node'
+        autoload :CvasgnNode,       'solargraph/parser/parser_gem/node_processors/cvasgn_node'
+        autoload :LvasgnNode,       'solargraph/parser/parser_gem/node_processors/lvasgn_node'
+        autoload :GvasgnNode,       'solargraph/parser/parser_gem/node_processors/gvasgn_node'
+        autoload :CasgnNode,        'solargraph/parser/parser_gem/node_processors/casgn_node'
+        autoload :MasgnNode,        'solargraph/parser/parser_gem/node_processors/masgn_node'
+        autoload :AliasNode,        'solargraph/parser/parser_gem/node_processors/alias_node'
+        autoload :ArgsNode,         'solargraph/parser/parser_gem/node_processors/args_node'
+        autoload :BlockNode,        'solargraph/parser/parser_gem/node_processors/block_node'
+        autoload :OrasgnNode,       'solargraph/parser/parser_gem/node_processors/orasgn_node'
+        autoload :OpasgnNode,       'solargraph/parser/parser_gem/node_processors/opasgn_node'
+        autoload :SymNode,          'solargraph/parser/parser_gem/node_processors/sym_node'
+        autoload :ResbodyNode,      'solargraph/parser/parser_gem/node_processors/resbody_node'
+        autoload :UntilNode,        'solargraph/parser/parser_gem/node_processors/until_node'
+        autoload :WhenNode,         'solargraph/parser/parser_gem/node_processors/when_node'
+        autoload :WhileNode,        'solargraph/parser/parser_gem/node_processors/while_node'
+        autoload :AndNode,          'solargraph/parser/parser_gem/node_processors/and_node'
+        autoload :OrNode,           'solargraph/parser/parser_gem/node_processors/or_node'
+        autoload :ClassDefinition,  'solargraph/parser/parser_gem/node_processors/class_definition'
+        autoload :StructDefinition, 'solargraph/parser/parser_gem/node_processors/struct_definition'
+        autoload :DataDefinition,   'solargraph/parser/parser_gem/node_processors/data_definition'
       end
     end
 
@@ -44,8 +47,8 @@ module Solargraph
       register :defs,         ParserGem::NodeProcessors::DefsNode
       register :if,           ParserGem::NodeProcessors::IfNode
       register :send,         ParserGem::NodeProcessors::SendNode
-      register :class,        Convention::StructDefinition::NodeProcessors::StructNode
-      register :class,        Convention::DataDefinition::NodeProcessors::DataNode
+      register :class,        ParserGem::NodeProcessors::StructDefinition::StructNode
+      register :class,        ParserGem::NodeProcessors::DataDefinition::DataNode
       register :class,        ParserGem::NodeProcessors::NamespaceNode
       register :module,       ParserGem::NodeProcessors::NamespaceNode
       register :sclass,       ParserGem::NodeProcessors::SclassNode
@@ -53,8 +56,9 @@ module Solargraph
       register :cvasgn,       ParserGem::NodeProcessors::CvasgnNode
       register :lvasgn,       ParserGem::NodeProcessors::LvasgnNode
       register :gvasgn,       ParserGem::NodeProcessors::GvasgnNode
-      register :casgn,        Convention::StructDefinition::NodeProcessors::StructNode
-      register :casgn,        Convention::DataDefinition::NodeProcessors::DataNode
+      register :casgn,        ParserGem::NodeProcessors::StructDefinition::StructNode
+      register :casgn,        ParserGem::NodeProcessors::DataDefinition::DataNode
+      register :casgn,        ParserGem::NodeProcessors::ClassDefinition::ClassNode
       register :casgn,        ParserGem::NodeProcessors::CasgnNode
       register :masgn,        ParserGem::NodeProcessors::MasgnNode
       register :alias,        ParserGem::NodeProcessors::AliasNode

data/lib/solargraph/pin/base.rb

@@ -158,7 +158,17 @@ module Solargraph
       # @param other [self]
       # @return [Pin::Closure, nil]
       def combine_closure other
-        choose_pin_attr_with_same_name(other, :closure)
+        chosen = choose_pin_attr_with_same_name(other, :closure)
+        return chosen unless chosen.is_a?(Pin::Namespace) && chosen.generics.empty?
+
+        # Combined types may name type parameters only the other closure declares
+        own = closure
+        return own if own.is_a?(Pin::Namespace) && !own.generics.empty?
+
+        theirs = other.closure
+        return theirs if theirs.is_a?(Pin::Namespace) && !theirs.generics.empty?
+
+        chosen
       end
 
       # @param other [self]
@@ -435,6 +445,7 @@ module Solargraph
       # @param context_type [ComplexType] The receiver type
       # @return [self]
       def resolve_generics definitions, context_type
+        definitions = declaring_definitions(definitions)
         transform_types { |t| t&.resolve_generics(definitions, context_type) }
       end
 
@@ -731,6 +742,19 @@ module Solargraph
 
       private
 
+      # Declarations of a reopened generic may spell its parameters
+      # differently, so bind by position against this pin's own one.
+      #
+      # @param definitions [Pin::Namespace, nil]
+      # @return [Pin::Namespace, nil]
+      def declaring_definitions definitions
+        own = closure
+        return definitions unless definitions.is_a?(Pin::Namespace) && own.is_a?(Pin::Namespace)
+        return definitions unless own.path == definitions.path && !own.generics.empty?
+
+        own
+      end
+
       # @return [void]
       def parse_comments
         # HACK: Avoid a NoMethodError on nil with empty overload tags

data/lib/solargraph/pin/base_variable.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'rbs'
+
 module Solargraph
   module Pin
     class BaseVariable < Base
@@ -14,6 +16,9 @@ module Solargraph
       # @return [Range, nil]
       attr_reader :presence
 
+      # @return [String, nil]
+      attr_reader :type_assertion
+
       # @param return_type [ComplexType, nil]
       # @param assignment [Parser::AST::Node, nil] First assignment
       #   that was made to this variable
@@ -45,12 +50,16 @@ module Solargraph
       # @see https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#union-types
       # @see https://en.wikipedia.org/wiki/Intersection_type#TypeScript_example
       # @param presence [Range, nil]
+      # @param type_assertion [String, nil] RBS type from a trailing
+      #   rbs-inline `#: TYPE` comment on the assignment
       # @param [Hash{Symbol => Object}] splat
       def initialize assignment: nil, assignments: [], mass_assignment: nil,
                      presence: nil, return_type: nil,
                      intersection_return_type: nil, exclude_return_type: nil,
+                     type_assertion: nil,
                      **splat
         super(**splat)
+        @type_assertion = type_assertion
         @assignments = (assignment.nil? ? [] : [assignment]) + assignments
         # @type [nil, ::Array(Parser::AST::Node, Integer)]
         @mass_assignment = mass_assignment
@@ -95,7 +104,8 @@ module Solargraph
                                   return_type: combine_return_type(other),
                                   intersection_return_type: combine_types(other, :intersection_return_type),
                                   exclude_return_type: combine_types(other, :exclude_return_type),
-                                  presence: combine_presence(other)
+                                  presence: combine_presence(other),
+                                  type_assertion: choose(other, :type_assertion)
                                 })
         super(other, new_attrs)
       end
@@ -170,6 +180,9 @@ module Solargraph
           end
         end
         types
+      rescue FileNotFoundError
+        # @todo Necessary for pins from source maps that are not part of the workspace
+        [ComplexType::UNDEFINED]
       end
 
       # @param api_map [ApiMap]
@@ -364,12 +377,29 @@ module Solargraph
         :instance
       end
 
+      # An rbs-inline type assertion takes precedence over a @type tag,
+      # as inline RBS method signatures do over YARD tags.
+      #
       # @return [ComplexType, nil]
       def generate_complex_type
+        asserted = type_from_assertion
+        return asserted unless asserted.nil?
         tag = docstring.tag(:type)
         return ComplexType.try_parse(*tag.types) unless tag.nil? || tag.types.nil? || tag.types.empty?
         nil
       end
+
+      # @return [ComplexType, nil]
+      def type_from_assertion
+        assertion = type_assertion
+        return nil if assertion.nil? || assertion.empty?
+        @type_from_assertion ||= begin
+          rbs_type = RBS::Parser.parse_type(assertion, require_eof: true)
+          RbsTranslator.to_complex_type(rbs_type) unless rbs_type.nil?
+        rescue RBS::ParsingError
+          nil
+        end
+      end
     end
   end
 end

data/lib/solargraph/pin/callable.rb

@@ -14,12 +14,15 @@ module Solargraph
       # @param block [Signature, nil]
       # @param return_type [ComplexType, nil]
       # @param parameters [::Array<Pin::Parameter>]
+      # @param block_required [Boolean] Whether callers must pass a block, per
+      #   an RBS non-optional block (`{ ... }` rather than `?{ ... }`).
       # @param [Hash{Symbol => Object}] splat
-      def initialize block: nil, return_type: nil, parameters: [], **splat
+      def initialize block: nil, return_type: nil, parameters: [], block_required: false, **splat
         super(**splat)
         @block = block
         @return_type = return_type
         @parameters = parameters
+        @block_required = block_required
       end
 
       def reset_generated!
@@ -55,6 +58,7 @@ module Solargraph
       def combine_with other, attrs = {}
         new_attrs = {
           block: combine_blocks(other),
+          block_required: block_required? || other.block_required?,
           return_type: combine_return_type(other)
         }.merge(attrs)
         new_attrs[:parameters] = choose_parameters(other).clone.freeze unless new_attrs.key?(:parameters)
@@ -241,7 +245,7 @@ module Solargraph
         argcount = arguments.length
         parcount = mandatory_positional_param_count
         parcount -= 1 if !parameters.empty? && parameters.last.block?
-        return false if block? && !with_block
+        return false if block? && block_required? && !with_block
         # @todo this and its caller should be changed so that this can
         #   look at the kwargs provided and check names against what
         #   we acccept
@@ -267,6 +271,11 @@ module Solargraph
         !!@block
       end
 
+      # @return [Boolean]
+      def block_required?
+        !!@block_required
+      end
+
       protected
 
       attr_writer :block

data/lib/solargraph/pin/delegated_method.rb

@@ -5,6 +5,11 @@ module Solargraph
     # A DelegatedMethod is a more complicated version of a MethodAlias that
     # allows aliasing a method from a different closure (class/module etc).
     class DelegatedMethod < Pin::Method
+      # @return [Boolean]
+      def body?
+        false
+      end
+
       # A DelegatedMethod can be constructed with either a :resolved_method
       # pin, or a :receiver_chain. When a :receiver_chain is supplied, it
       # will be used to *dynamically* resolve a receiver type within the

data/lib/solargraph/pin/duck_method.rb

@@ -1,16 +1,36 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Pin
-    # DuckMethod pins are used to add completion items for type tags that
-    # use duck typing, e.g., `@param file [#read]`.
-    #
-    class DuckMethod < Pin::Method
-      # @param location [Solargraph::Location]
-      # @param name [String]
-      # def initialize location, name
-      #   # super(location, '', name, nil, :instance, :public, [])
-      # end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    # DuckMethod pins are used to add completion items for type tags that
+    # use duck typing, e.g., `@param file [#read]`.
+    #
+    class DuckMethod < Pin::Method
+      # A duck-type tag has no syntax for arguments, so the default empty
+      # #parameters would synthesize a zero-arg signature no real call matches.
+      #
+      # @param splat [Hash{Symbol => Object}]
+      def initialize **splat
+        super(parameters: accepts_any_arguments, **splat)
+      end
+
+      # @return [::Array<Pin::Parameter>]
+      def accepts_any_arguments
+        [
+          Pin::Parameter.new(decl: :restarg, name: 'args', closure: self, source: :api_map),
+          Pin::Parameter.new(decl: :kwrestarg, name: 'kwargs', closure: self, source: :api_map)
+        ]
+      end
+
+      # A synthetic pin sits in no ancestor chain and has no closure. Letting
+      # the inherited walk find a type sends #typify on to `closure.gates`,
+      # which raises.
+      #
+      # @param _api_map [ApiMap]
+      # @return [Array<Pin::Method>]
+      def rest_of_stack _api_map
+        []
+      end
+    end
+  end
+end

data/lib/solargraph/pin/instance_variable.rb

@@ -33,6 +33,51 @@ module Solargraph
       def nearly? other
         super && binder == other.binder
       end
+
+      # Same-file requirement only applies when +presence+ is set; an
+      # unnarrowed ivar has none and can be assigned and read in
+      # different files (e.g. ancestor class's method vs. descendant's).
+      #
+      # @param other_closure [Pin::Closure]
+      # @param other_loc [Location]
+      def visible_at? other_closure, other_loc
+        return false if presence && location&.filename != other_loc.filename
+        # @sg-ignore flow sensitive typing needs to handle attrs
+        return false if presence && !presence.include?(other_loc.range.start)
+
+        visible_in_closure?(other_closure)
+      end
+
+      private
+
+      # Unlike BaseVariable, doesn't stop at a lexically-mismatched
+      # Namespace pin: #get_instance_variable_pins already restricts
+      # candidates to the reading namespace and its ancestors, so
+      # reaching one here means visible via inheritance.
+      #
+      # @param viewing_closure [Pin::Closure]
+      # @return [Boolean]
+      def visible_in_closure? viewing_closure
+        return false if closure.nil?
+
+        # top-level ivars aren't visible from within a method
+        # @sg-ignore Need to add nil check here
+        return false if viewing_closure.is_a?(Pin::Method) && closure.context.tags == 'Class<>'
+
+        # @sg-ignore Need to add nil check here
+        return true if viewing_closure.binder.namespace == closure.binder.namespace
+
+        # @sg-ignore Need to add nil check here
+        return true if viewing_closure.return_type == closure.context
+
+        return true if viewing_closure.is_a?(Pin::Namespace)
+
+        parent_of_viewing_closure = viewing_closure.closure
+
+        return false if parent_of_viewing_closure.nil?
+
+        visible_in_closure?(parent_of_viewing_closure)
+      end
     end
   end
 end

data/lib/solargraph/pin/method.rb

@@ -370,6 +370,13 @@ module Solargraph
         @explicit
       end
 
+      # False for method pins synthesized from a class-body statement rather than parsed from a def.
+      #
+      # @return [Boolean]
+      def body?
+        !attribute?
+      end
+
       def attribute?
         @attribute
       end
@@ -387,6 +394,9 @@ module Solargraph
 
       def probe api_map
         attribute? ? infer_from_iv(api_map) : infer_from_return_nodes(api_map)
+      rescue FileNotFoundError
+        # @todo Necessary for pins from source maps that are not part of the workspace
+        ComplexType::UNDEFINED
       end
 
       # @return [::Array<Pin::Signature>]

data/lib/solargraph/pin/method_alias.rb

@@ -7,6 +7,10 @@ module Solargraph
     # methods from included modules.
     #
     class MethodAlias < Method
+      # @return [Boolean]
+      def body?
+        false
+      end
       # @return [::Symbol]
       attr_reader :scope
 

data/lib/solargraph/pin/parameter.rb

@@ -115,7 +115,7 @@ module Solargraph
       end
 
       def rest?
-        %i[restarg kwrestarg].include?(decl)
+        %i[restarg kwrestarg forward_args].include?(decl)
       end
 
       def block?

data/lib/solargraph/pin/reference/included_mixin.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    class Reference
+      # A mixin that a module's +self.included+ hook applies to every class
+      # that includes the module, e.g. +base.extend ClassMethods+. The closure
+      # is the hooking module and the name is the mixed-in module.
+      class IncludedMixin < Reference
+        # @return [::Symbol] :include, :prepend or :extend
+        attr_reader :keyword
+
+        # @param keyword [::Symbol] :include, :prepend or :extend
+        # @param splat [Hash{Symbol => Object}]
+        def initialize keyword:, **splat
+          super(**splat)
+          @keyword = keyword
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/pin/reference.rb

@@ -8,6 +8,7 @@ module Solargraph
       autoload :Include,    'solargraph/pin/reference/include'
       autoload :Prepend,    'solargraph/pin/reference/prepend'
       autoload :Extend,     'solargraph/pin/reference/extend'
+      autoload :IncludedMixin, 'solargraph/pin/reference/included_mixin'
       autoload :Override,   'solargraph/pin/reference/override'
       autoload :TypeAlias,  'solargraph/pin/reference/type_alias'
 

data/lib/solargraph/plugin/active_support.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Plugin
+    class ActiveSupport < Base
+      ATTRIBUTE_NAME = /\A[_A-Za-z]\w*\z/
+
+      def addon
+        return EMPTY_ADDON unless gem_names.include?('activesupport')
+
+        Addon.new(pins: classmethod_pins + attribute_pins)
+      end
+
+      private
+
+      def classmethod_pins
+        pins_by_class(Pin::Reference::Include).map do |inc|
+          Pin::Reference::Extend.new(name: "#{inc.name}::ClassMethods", closure: inc.closure)
+        end
+      end
+
+      def attribute_pins
+        source_maps.flat_map { |map| map.calls(:class_attribute, :mattr_accessor, :cattr_accessor, :mattr_reader, :cattr_reader, :mattr_writer, :cattr_writer, :config_accessor) }
+                   .select { |call| call.closure.is_a?(Pin::Namespace) }
+                   .flat_map { |call| generate_call_pins(call) }
+                   .compact
+      end
+
+      # @param call [SourceMap::Call]
+      def generate_call_pins call
+        options = option_hash(call.chain.links.last.arguments.last)
+        method_names = call.chain.links.last.arguments.select(&:literal?).map { |arg| arg.links.last.value }.compact
+                           .grep(ATTRIBUTE_NAME)
+        case call.chain.links.last.word
+        when 'class_attribute'
+          class_suffixes = ['', '=']
+          class_suffixes.push '?' if options[:instance_predicate]
+          instance_suffixes = []
+          instance_suffixes.push '' if options[:instance_accessor] && options[:instance_reader]
+          instance_suffixes.push '=' if options[:instance_accessor] && options[:instance_writer]
+          instance_suffixes.push '?' if options[:instance_accessor] && options[:instance_predicate]
+          method_names.flat_map { |name| method_pins(name, class_suffixes, instance_suffixes, call) }
+        when 'mattr_accessor', 'cattr_accessor', 'config_accessor'
+          class_suffixes = ['', '=']
+          instance_suffixes = []
+          instance_suffixes.push '' if options[:instance_accessor] && options[:instance_reader]
+          instance_suffixes.push '=' if options[:instance_accessor] && options[:instance_writer]
+          method_names.flat_map { |name| method_pins(name, class_suffixes, instance_suffixes, call) }
+        when 'mattr_reader', 'cattr_reader'
+          class_suffixes = ['']
+          instance_suffixes = []
+          instance_suffixes.push '' if options[:instance_accessor] && options[:instance_reader]
+          method_names.flat_map { |name| method_pins(name, class_suffixes, instance_suffixes, call) }
+        when 'mattr_writer', 'cattr_writer'
+          class_suffixes = ['=']
+          instance_suffixes = []
+          instance_suffixes.push '=' if options[:instance_accessor] && options[:instance_writer]
+          method_names.flat_map { |name| method_pins(name, class_suffixes, instance_suffixes, call) }
+        else
+          []
+        end
+      end
+
+      def option_hash args
+        defaults = {
+          instance_reader: true,
+          instance_writer: true,
+          instance_accessor: true,
+          instance_predicate: true
+        }
+        kwargs = Parser::ParserGem::NodeMethods.convert_hash(args.node)
+                                               .select { |_, val| val.literal? }
+                                               .transform_values { |val| val.links.last.value }
+        return defaults unless kwargs.is_a?(Hash)
+        defaults.merge(kwargs)
+      end
+
+      # @param call [SourceMap::Call]
+      # @param name [String]
+      # @param class_suffixes [Array<String>]
+      # @param instance_suffixes [Array<String>]
+      def method_pins name, class_suffixes, instance_suffixes, call
+        comments = call.source_map.source.comments_for(call.chain.node)
+        location = Solargraph::Location.new(call.closure.filename, Solargraph::Range.from_node(call.chain.node))
+        class_suffixes.map do |sfx|
+          Pin::Method.new(name: "#{name}#{sfx}", closure: call.closure, scope: :class, attribute: true, location: location, comments: comments).tap do |pin|
+            next unless sfx == '='
+            pin.parameters.push Pin::Parameter.new(name: 'value', closure: pin)
+          end
+        end +
+          instance_suffixes.map do |sfx|
+            Pin::Method.new(name: "#{name}#{sfx}", closure: call.closure, scope: :instance, attribute: true, location: location, comments: comments).tap do |pin|
+              next unless sfx == '='
+              pin.parameters.push Pin::Parameter.new(name: 'value', closure: pin)
+            end
+          end
+      end
+    end
+  end
+end

data/lib/solargraph/plugin/addon.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Plugin
+    class Addon
+      attr_reader :gem_names, :pins
+
+      # @param gem_names [Array<String>]
+      # @param pins [Array<Pin::Base>]
+      def initialize gem_names: [], pins: []
+        @gem_names = gem_names
+        @pins = pins
+      end
+    end
+  end
+end

data/lib/solargraph/plugin/base.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module Solargraph
+  module Plugin
+    class Base
+      extend Forwardable
+
+      attr_reader :panel
+
+      def_delegators :@panel, :pins, :pins_by_class, :pins_by_path, :gem_names, :source_maps
+
+      # @param panel [Panel]
+      def initialize panel
+        @panel = panel
+      end
+
+      # @return [Addon]
+      def addon
+        EMPTY_ADDON
+      end
+    end
+  end
+end

data/lib/solargraph/plugin/panel.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Plugin
+    class Panel
+      attr_reader :source_maps, :live_map, :gem_names
+
+      def initialize source_maps: [], live_map: nil, gem_names: []
+        @source_maps = source_maps
+        @live_map = live_map
+        @gem_names = gem_names
+      end
+
+      def pins
+        @pins ||= source_maps.flat_map(&:pins)
+      end
+
+      def pins_by_class klass
+        pin_class_hash[klass] || []
+      end
+
+      def pins_by_path path
+        pin_path_hash[path] || []
+      end
+
+      private
+
+      def pin_class_hash
+        @pin_class_hash ||= pins.to_set.classify(&:class)
+      end
+
+      def pin_path_hash
+        @pin_path_hash ||= pins.to_set.classify(&:path)
+      end
+    end
+  end
+end

data/lib/solargraph/plugin.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Plugin
+    autoload :Addon, 'solargraph/plugin/addon'
+    autoload :Base, 'solargraph/plugin/base'
+    autoload :Panel, 'solargraph/plugin/panel'
+    autoload :ActiveSupport, 'solargraph/plugin/active_support'
+
+    EMPTY_ADDON = Addon.new.freeze
+
+    def self.registry
+      @registry ||= Set.new
+    end
+
+    def self.register klass
+      registry.add klass
+    end
+
+    def self.unregister klass
+      registry.delete klass
+    end
+
+    Plugin.register ActiveSupport
+  end
+end