solargraph 0.59.2 → 0.60.0

data/lib/solargraph/shell.rb

@@ -4,10 +4,14 @@ require 'benchmark'
 require 'thor'
 require 'yard'
 require 'yaml'
+require 'sord'
+require 'tmpdir'
+
 
 module Solargraph
   class Shell < Thor
     include Solargraph::ServerMethods
+    include ApiMap::SourceToYard
 
     # Tell Thor to ensure the process exits with status 1 if any error happens.
     def self.exit_on_failure?
@@ -112,12 +116,10 @@ module Solargraph
         PinCache.serialize_yard_gem(gemspec, pins)
       end
 
-      workspace = Solargraph::Workspace.new(Dir.pwd)
-      rbs_map = RbsMap.from_gemspec(gemspec, workspace.rbs_collection_path, workspace.rbs_collection_config_path)
+      workspace = Solargraph::Workspace.new(Dir.pwd) if File.exist?('rbs_collection.yaml')
+      rbs_map = RbsMap.from_gemspec(gemspec, workspace&.rbs_collection_path, workspace&.rbs_collection_config_path)
       if options[:rebuild] || !PinCache.has_rbs_collection?(gemspec, rbs_map.cache_key)
-        # cache pins even if result is zero, so we don't retry building pins
-        pins = rbs_map.pins || []
-        PinCache.serialize_rbs_collection_gem(gemspec, rbs_map.cache_key, pins)
+        PinCache.serialize_rbs_collection_gem(gemspec, rbs_map.cache_key, rbs_map.pins)
       end
     rescue Gem::MissingSpecError
       warn "Gem '#{gem}' not found"
@@ -261,7 +263,7 @@ module Solargraph
           next if problems.empty?
           problems.sort! { |a, b| a.location.range.start.line <=> b.location.range.start.line }
           puts problems.map { |prob|
-            "#{prob.location.filename}:#{prob.location.range.start.line + 1} - #{prob.message}"
+            "#{prob.location.filename}:#{prob.location.range.start.line + 1}: #{prob.message}"
           }.join("\n")
           filecount += 1
           probcount += problems.length
@@ -420,74 +422,139 @@ module Solargraph
         puts "Notification: #{method} - #{params}"
       end
 
-      puts 'Parsing and mapping source files...'
-      prepare_start = Time.now
-      Vernier.profile(out: "#{options[:output_dir]}/parse_benchmark.json.gz", hooks: hooks) do
-        puts 'Mapping libraries'
-        host.prepare(directory)
-        sleep 0.2 until host.libraries.all?(&:mapped?)
+      parse_path = File.join(options[:output_dir], 'parse_benchmark.json.gz')
+      catalog_path = File.join(options[:output_dir], 'catalog_benchmark.json.gz')
+      definition_path = File.join(options[:output_dir], 'definition_benchmark.json.gz')
+
+      prepare_time = catalog_time = definition_time = nil
+
+      # Trap CTRL-C so the in-progress Vernier.profile block can unwind through
+      # its ensure clause and still write its output file. A second CTRL-C
+      # restores default handling for a hard exit.
+      interrupted = false
+      previous_int_trap = Signal.trap('INT') do
+        if interrupted
+          Signal.trap('INT', 'DEFAULT')
+          Process.kill('INT', Process.pid)
+        else
+          interrupted = true
+          puts "\nInterrupted. Finishing current profile (CTRL-C again to force exit)..."
+          raise Interrupt
+        end
       end
-      prepare_time = Time.now - prepare_start
 
-      puts 'Building the catalog...'
-      catalog_start = Time.now
-      Vernier.profile(out: "#{options[:output_dir]}/catalog_benchmark.json.gz", hooks: hooks) do
-        host.catalog
-      end
-      catalog_time = Time.now - catalog_start
+      begin
+        puts 'Parsing and mapping source files...'
+        prepare_start = Time.now
+        Vernier.profile(out: parse_path, hooks: hooks) do
+          puts 'Mapping libraries'
+          host.prepare(directory)
+          sleep 0.2 until host.libraries.all?(&:mapped?)
+        end
+        prepare_time = Time.now - prepare_start
 
-      # Determine test file
-      if file
-        test_file = File.join(directory, file)
-      else
-        test_file = File.join(directory, 'lib', 'other.rb')
-        unless File.exist?(test_file)
-          # Fallback to any Ruby file in the workspace
-          workspace = Solargraph::Workspace.new(directory)
-          test_file = workspace.filenames.find { |f| f.end_with?('.rb') }
-          unless test_file
-            warn 'No Ruby files found in workspace'
-            return
+        puts 'Building the catalog...'
+        catalog_start = Time.now
+        Vernier.profile(out: catalog_path, hooks: hooks) do
+          host.catalog
+        end
+        catalog_time = Time.now - catalog_start
+
+        # Determine test file
+        if file
+          test_file = File.join(directory, file)
+        else
+          test_file = File.join(directory, 'lib', 'other.rb')
+          unless File.exist?(test_file)
+            # Fallback to any Ruby file in the workspace
+            workspace = Solargraph::Workspace.new(directory)
+            test_file = workspace.filenames.find { |f| f.end_with?('.rb') }
+            unless test_file
+              puts 'No Ruby files found in workspace'
+              return
+            end
           end
         end
-      end
 
-      file_uri = Solargraph::LanguageServer::UriHelpers.file_to_uri(File.absolute_path(test_file))
+        file_uri = Solargraph::LanguageServer::UriHelpers.file_to_uri(File.absolute_path(test_file))
 
-      puts "Profiling go-to-definition for #{test_file}"
-      puts "Position: line #{options[:line]}, column #{options[:column]}"
+        puts "Profiling go-to-definition for #{test_file}"
+        puts "Position: line #{options[:line]}, column #{options[:column]}"
 
-      definition_start = Time.now
-      Vernier.profile(out: "#{options[:output_dir]}/definition_benchmark.json.gz", hooks: hooks) do
-        message = Solargraph::LanguageServer::Message::TextDocument::Definition.new(
-          host, {
-            'params' => {
-              'textDocument' => { 'uri' => file_uri },
-              'position' => { 'line' => options[:line], 'character' => options[:column] }
+        definition_start = Time.now
+        Vernier.profile(out: definition_path, hooks: hooks) do
+          message = Solargraph::LanguageServer::Message::TextDocument::Definition.new(
+            host, {
+              'params' => {
+                'textDocument' => { 'uri' => file_uri },
+                'position' => { 'line' => options[:line], 'character' => options[:column] }
+              }
             }
-          }
-        )
-        puts 'Processing go-to-definition request...'
-        result = message.process
+          )
+          puts 'Processing go-to-definition request...'
+          result = message.process
+
+          puts "Result: #{result.inspect}"
+        end
+        definition_time = Time.now - definition_start
+      rescue Interrupt
+        puts "\nProfile run interrupted; partial profile(s) have been written."
+      ensure
+        Signal.trap('INT', previous_int_trap || 'DEFAULT')
+
+        puts "\n=== Timing Results ==="
+        puts "Parsing & mapping: #{(prepare_time * 1000).round(2)}ms" if prepare_time
+        puts "Catalog building: #{(catalog_time * 1000).round(2)}ms" if catalog_time
+        puts "Go-to-definition: #{(definition_time * 1000).round(2)}ms" if definition_time
+        if prepare_time && catalog_time && definition_time
+          total_time = prepare_time + catalog_time + definition_time
+          puts "Total time: #{(total_time * 1000).round(2)}ms"
+        end
+
+        saved = [parse_path, catalog_path, definition_path].select { |p| File.exist?(p) }
+        unless saved.empty?
+          puts "\nProfiles saved to:"
+          saved.each { |p| puts "  - #{File.expand_path(p)}" }
+
+          puts "\nUpload the JSON files to https://vernier.prof/ to view the profiles."
+          puts 'Or use https://rubygems.org/gems/profile-viewer to view them locally.'
+        end
+      end
+    end
 
-        puts "Result: #{result.inspect}"
+    desc 'rbs', 'Generate RBS definitions'
+    option :filename, type: :string, alias: :f, desc: 'Generated file name', default: 'sig.rbs'
+    option :inference, type: :boolean, desc: 'Enhance definitions with type inference', default: true
+    def rbs
+      api_map = Solargraph::ApiMap.load('.')
+      pins = api_map.source_maps.flat_map(&:pins)
+      store = Solargraph::ApiMap::Store.new(pins)
+      if options[:inference]
+        puts 'Inferring untyped methods...'
+        store.method_pins.each do |pin|
+          next unless pin.return_type.undefined?
+          type = pin.typify(api_map)
+          type = pin.probe(api_map) if type.undefined?
+          pin.docstring.add_tag YARD::Tags::Tag.new('return', nil, type.items.map(&:to_s))
+          pin.instance_variable_set(:@return_type, type)
+        end
+      end
+      puts 'Generating yardocs...'
+      rake_yard(store)
+      work_dir = Dir.pwd
+      Dir.mktmpdir do |tmpdir|
+        Dir.chdir tmpdir do
+          yardoc = File.join(tmpdir, '.yardoc')
+          YARD::Registry.save(false, yardoc)
+          YARD::Registry.load(yardoc)
+          rel_dir = File.join('sig', options[:filename])
+          puts "Writing #{rel_dir}..."
+          target = File.join(work_dir, rel_dir)
+          FileUtils.mkdir_p(File.join(work_dir, 'sig'))
+          `sord #{target} --rbs --no-regenerate`
+        end
       end
-      definition_time = Time.now - definition_start
-
-      puts "\n=== Timing Results ==="
-      puts "Parsing & mapping: #{(prepare_time * 1000).round(2)}ms"
-      puts "Catalog building: #{(catalog_time * 1000).round(2)}ms"
-      puts "Go-to-definition: #{(definition_time * 1000).round(2)}ms"
-      total_time = prepare_time + catalog_time + definition_time
-      puts "Total time: #{(total_time * 1000).round(2)}ms"
-
-      puts "\nProfiles saved to:"
-      puts "  - #{File.expand_path('parse_benchmark.json.gz', options[:output_dir])}"
-      puts "  - #{File.expand_path('catalog_benchmark.json.gz', options[:output_dir])}"
-      puts "  - #{File.expand_path('definition_benchmark.json.gz', options[:output_dir])}"
-
-      puts "\nUpload the JSON files to https://vernier.prof/ to view the profiles."
-      puts 'Or use https://rubygems.org/gems/profile-viewer to view them locally.'
+      puts 'Done.'
     end
 
     private

data/lib/solargraph/source/chain/call.rb

@@ -127,10 +127,15 @@ module Solargraph
                                 block_call_type(api_map, name_pin, locals)
                               end
                 end
-                # @type new_signature_pin [Pin::Signature]
                 new_signature_pin = ol.resolve_generics_from_context_until_complete(ol.generics, atypes, nil, nil,
                                                                                     blocktype)
-                new_return_type = new_signature_pin.return_type
+                # @todo It shouldn't be necessary to choose either generics or macros
+                new_return_type = if new_signature_pin.return_type.defined?
+                  new_signature_pin.return_type
+                else
+                  named_types = p.parameter_names.zip(arguments.map { |arg| ComplexType.try_parse(simple_convert(arg.node).to_s) }).to_h
+                  p.typify(api_map).expand(named_types)
+                end
                 self_type = if head?
                               # If we're at the head of the chain, we called a
                               # method somewhere that marked itself as returning
@@ -153,8 +158,7 @@ module Solargraph
                 # the docs were written - from the method pin.
                 # @todo Need to add nil check here
                 if new_return_type.defined?
-                  type = with_params(new_return_type.self_to_type(self_type), self_type).qualify(api_map,
-                                                                                                 *p.gates)
+                  type = with_params(new_return_type.self_to_type(self_type), self_type).qualify(api_map, *p.gates)
                 end
                 type ||= ComplexType::UNDEFINED
               end
@@ -162,15 +166,6 @@ module Solargraph
             end
             p = p.with_single_signature(new_signature_pin) unless new_signature_pin.nil?
             next p.proxy(type) if type.defined?
-            if !p.macros.empty?
-              result = process_macro(p, api_map, name_pin.context, locals)
-              # @sg-ignore flow sensitive typing should be able to handle redefinition
-              next result unless result.return_type.undefined?
-            elsif !p.directives.empty?
-              result = process_directive(p, api_map, name_pin.context, locals)
-              # @sg-ignore flow sensitive typing should be able to handle redefinition
-              next result unless result.return_type.undefined?
-            end
             p
           end
           logger.debug do
@@ -191,69 +186,6 @@ module Solargraph
           end
         end
 
-        # @param pin [Pin::Base]
-        # @param api_map [ApiMap]
-        # @param context [ComplexType, ComplexType::UniqueType]
-        # @param locals [::Array<Solargraph::Pin::LocalVariable, Solargraph::Pin::Parameter>]
-        # @return [Pin::Base]
-        def process_macro pin, api_map, context, locals
-          pin.macros.each do |macro|
-            # @todo 'Wrong argument type for
-            #   Solargraph::Source::Chain::Call#inner_process_macro:
-            #   macro expected YARD::Tags::MacroDirective, received
-            #   generic<Elem>' is because we lose 'rooted' information
-            #   in the 'Chain::Array' class internally, leaving
-            #   ::Array#each shadowed when it shouldn't be.
-            result = inner_process_macro(pin, macro, api_map, context, locals)
-            return result unless result.return_type.undefined?
-          end
-          Pin::ProxyType.anonymous(ComplexType::UNDEFINED, source: :chain)
-        end
-
-        # @param pin [Pin::Method]
-        # @param api_map [ApiMap]
-        # @param context [ComplexType, ComplexType::UniqueType]
-        # @param locals [::Array<Solargraph::Pin::LocalVariable, Solargraph::Pin::Parameter>]
-        # @return [Pin::ProxyType]
-        def process_directive pin, api_map, context, locals
-          pin.directives.each do |dir|
-            macro = api_map.named_macro(dir.tag.name)
-            next if macro.nil?
-            result = inner_process_macro(pin, macro, api_map, context, locals)
-            return result unless result.return_type.undefined?
-          end
-          Pin::ProxyType.anonymous ComplexType::UNDEFINED, source: :chain
-        end
-
-        # @param pin [Pin::Base]
-        # @param macro [YARD::Tags::MacroDirective]
-        # @param api_map [ApiMap]
-        # @param context [ComplexType, ComplexType::UniqueType]
-        # @param locals [::Array<Pin::LocalVariable, Pin::Parameter>]
-        # @return [Pin::ProxyType]
-        def inner_process_macro pin, macro, api_map, context, locals
-          vals = arguments.map { |c| Pin::ProxyType.anonymous(c.infer(api_map, pin, locals), source: :chain) }
-          txt = macro.tag.text.clone
-          # @sg-ignore Need to add nil check here
-          if txt.empty? && macro.tag.name
-            named = api_map.named_macro(macro.tag.name)
-            txt = named.tag.text.clone if named
-          end
-          i = 1
-          vals.each do |v|
-            # @sg-ignore Need to add nil check here
-            txt.gsub!(/\$#{i}/, v.context.namespace)
-            i += 1
-          end
-          # @sg-ignore Need to add nil check here
-          docstring = Solargraph::Source.parse_docstring(txt).to_docstring
-          tag = docstring.tag(:return)
-          unless tag.nil? || tag.types.nil?
-            return Pin::ProxyType.anonymous(ComplexType.try_parse(*tag.types), source: :chain)
-          end
-          Pin::ProxyType.anonymous(ComplexType::UNDEFINED, source: :chain)
-        end
-
         # @param docstring [YARD::Docstring]
         # @param context [ComplexType]
         # @return [ComplexType, nil]

data/lib/solargraph/source_map/mapper.rb

@@ -61,13 +61,6 @@ module Solargraph
         @pins ||= []
       end
 
-      # @param position [Solargraph::Position]
-      # @return [Solargraph::Pin::Closure]
-      def closure_at position
-        # @sg-ignore Need to add nil check here
-        pins.select { |pin| pin.is_a?(Pin::Closure) and pin.location.range.contain?(position) }.last
-      end
-
       # @param source_position [Position]
       # @param comment_position [Position]
       # @param comment [String]
@@ -108,135 +101,12 @@ module Solargraph
       # @param directive [YARD::Tags::Directive]
       # @return [void]
       def process_directive source_position, comment_position, directive
-        # @sg-ignore Need to add nil check here
-        docstring = Solargraph::Source.parse_docstring(directive.tag.text).to_docstring
-        location = Location.new(@filename, Range.new(comment_position, comment_position))
-        case directive.tag.tag_name
-        when 'method'
-          namespace = closure_at(source_position) || @pins.first
-          # @sg-ignore Need to add nil check here
-          namespace = closure_at(comment_position) if namespace.location.range.start.line < comment_position.line
-          begin
-            src = Solargraph::Source.load_string("def #{directive.tag.name};end", @source.filename)
-            region = Parser::Region.new(source: src, closure: namespace)
-            # @type [Array<Pin::Method>]
-            method_gen_pins = Parser.process_node(src.node, region).first.select { |pin| pin.is_a?(Pin::Method) }
-            gen_pin = method_gen_pins.last
-            return if gen_pin.nil?
-            # Move the location to the end of the line so it gets recognized
-            # as originating from a comment
-            shifted = Solargraph::Position.new(comment_position.line,
-                                               @code.lines[comment_position.line].to_s.chomp.length)
-            # @todo: Smelly instance variable access
-            gen_pin.instance_variable_set(:@comments, docstring.all.to_s)
-            gen_pin.instance_variable_set(:@location, Solargraph::Location.new(@filename, Range.new(shifted, shifted)))
-            gen_pin.instance_variable_set(:@explicit, false)
-            @pins.push gen_pin
-          rescue Parser::SyntaxError
-            # @todo Handle error in directive
-          end
-        when 'attribute'
-          return if directive.tag.name.nil?
-          namespace = closure_at(source_position)
-          t = directive.tag.types.nil? || directive.tag.types.empty? ? nil : directive.tag.types.join
-          if t.nil? || t.include?('r')
-            pins.push Solargraph::Pin::Method.new(
-              location: location,
-              closure: namespace,
-              name: directive.tag.name,
-              comments: docstring.all.to_s,
-              scope: namespace.is_a?(Pin::Singleton) ? :class : :instance,
-              visibility: :public,
-              explicit: false,
-              attribute: true,
-              source: :source_map
-            )
-          end
-          if t.nil? || t.include?('w')
-            method_pin = Solargraph::Pin::Method.new(
-              location: location,
-              closure: namespace,
-              name: "#{directive.tag.name}=",
-              comments: docstring.all.to_s,
-              scope: namespace.is_a?(Pin::Singleton) ? :class : :instance,
-              visibility: :public,
-              attribute: true,
-              source: :source_map
-            )
-            pins.push method_pin
-            method_pin.parameters.push Pin::Parameter.new(name: 'value', decl: :arg, closure: pins.last,
-                                                          source: :source_map)
-            if pins.last.return_type.defined?
-              pins.last.docstring.add_tag YARD::Tags::Tag.new(:param, '', pins.last.return_type.to_s.split(', '),
-                                                              'value')
-            end
-          end
-        when 'visibility'
+        directive_processor = YardMap::Directives.for(directive)
+        return unless directive_processor
 
-          kind = directive.tag.text&.to_sym
-          return unless %i[private protected public].include?(kind)
-
-          name = directive.tag.name
-          closure = closure_at(source_position) || @pins.first
-          # @sg-ignore Need to add nil check here
-          closure = closure_at(comment_position) if closure.location.range.start.line < comment_position.line
-          if closure.is_a?(Pin::Method) && no_empty_lines?(comment_position.line, source_position.line)
-            # @todo Smelly instance variable access
-            closure.instance_variable_set(:@visibility, kind)
-          else
-            matches = pins.select do |pin|
-              pin.is_a?(Pin::Method) && pin.name == name && pin.namespace == namespace && pin.context.scope == namespace.is_a?(Pin::Singleton) ? :class : :instance
-            end
-            matches.each do |pin|
-              # @todo Smelly instance variable access
-              pin.instance_variable_set(:@visibility, kind)
-            end
-          end
-
-        when 'parse'
-          begin
-            ns = closure_at(source_position)
-            # @sg-ignore Need to add nil check here
-            src = Solargraph::Source.load_string(directive.tag.text, @source.filename)
-            region = Parser::Region.new(source: src, closure: ns)
-            # @todo These pins may need to be marked not explicit
-            index = @pins.length
-            loff = if @code.lines[comment_position.line].strip.end_with?('@!parse')
-                     comment_position.line + 1
-                   else
-                     comment_position.line
-                   end
-            locals = []
-            ivars = []
-            Parser.process_node(src.node, region, @pins, locals, ivars)
-            @pins.concat ivars
-            # @sg-ignore Need to add nil check here
-            @pins[index..].each do |p|
-              # @todo Smelly instance variable access
-              p.location.range.start.instance_variable_set(:@line, p.location.range.start.line + loff)
-              p.location.range.ending.instance_variable_set(:@line, p.location.range.ending.line + loff)
-            end
-          rescue Parser::SyntaxError
-            # @todo Handle parser errors in !parse directives
-          end
-        when 'domain'
-          namespace = closure_at(source_position) || Pin::ROOT_PIN
-          # @sg-ignore flow sensitive typing should be able to handle redefinition
-          namespace.domains.concat directive.tag.types unless directive.tag.types.nil?
-        when 'override'
-          pins.push Pin::Reference::Override.new(location, directive.tag.name, docstring.tags,
-                                                 source: :source_map)
-        when 'macro'
-          # @todo Handle macros
-        end
-      end
-
-      # @param line1 [Integer]
-      # @param line2 [Integer]
-      # @sg-ignore Need to add nil check here
-      def no_empty_lines? line1, line2
-        # @sg-ignore Need to add nil check here
-        @code.lines[line1..line2].none? { |line| line.strip.empty? }
+        @pins += directive_processor.process_directive(
+          @source, @pins, source_position, comment_position, directive
+        )
       end
 
       # @param comment [String]

data/lib/solargraph/source_map.rb

@@ -152,6 +152,20 @@ module Solargraph
       locals.select { |pin| pin.visible_at?(closure, location) }
     end
 
+    # @return [Array<Parser::AST::Node>]
+    def method_call_nodes
+      # @sg-ignore node expected Parser::AST::Node, received Parser::AST::Node, nil
+      @method_call_nodes ||= Solargraph::Parser::ParserGem::NodeMethods.call_nodes_from(source.node)
+    end
+
+    # @param macro_method_names [Array<String>]
+    # @return [Array<Parser::AST::Node>]
+    def macro_method_candidates macro_method_names
+      return @macro_method_candidates if @macro_method_names == macro_method_names
+      @macro_method_names = macro_method_names
+      @macro_method_candidates = method_call_nodes.select { |node| macro_method_names.include?(node.children[1].to_s) }
+    end
+
     class << self
       # @param filename [String]
       # @return [SourceMap]

data/lib/solargraph/version.rb

@@ -1,5 +1,23 @@
 # frozen_string_literal: true
 
 module Solargraph
-  VERSION = ENV.fetch('SOLARGRAPH_FORCE_VERSION', '0.59.2')
+  VERSION = ENV.fetch('SOLARGRAPH_FORCE_VERSION', '0.60.0')
+end
+
+# @generic T
+class A
+  # @yieldparam param0 [generic<T>]
+  def foo
+  end
+end
+
+class B < A # [Integer]
+  def bar
+    foo { |param0| }
+  end
+end
+
+b = B.new
+b.foo do |arg|
+  arg #=> Integer
 end

data/lib/solargraph/yard_map/directives/attribute_directive.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class YardMap
+    module Directives
+      module AttributeDirective
+        module_function
+
+        # @param source [Solargraph::Source]
+        # @param pins [Array<Solargraph::Pin::Base>]
+        # @param source_position [Position]
+        # @param comment_position [Position]
+        # @param directive [YARD::Tags::Directive]
+        # @return [Array<Solargraph::Pin::Method>]
+        def process_directive source, pins, source_position, comment_position, directive
+          new_pins = []
+          location = Location.new(source.filename, Range.new(comment_position, comment_position))
+          docstring = Solargraph::Source.parse_docstring(directive.tag.text.to_s).to_docstring
+          return [] if directive.tag.name.nil?
+          namespace = closure_at(pins, source_position)
+          t = directive.tag.types.nil? || directive.tag.types.empty? ? nil : directive.tag.types.join
+          if t.nil? || t.include?('r')
+            new_pins.push Solargraph::Pin::Method.new(
+              location: location,
+              closure: namespace,
+              name: directive.tag.name,
+              comments: docstring.all.to_s,
+              scope: namespace.is_a?(Pin::Singleton) ? :class : :instance,
+              visibility: :public,
+              explicit: false,
+              attribute: true,
+              source: :yard_map
+            )
+          end
+          if t.nil? || t.include?('w')
+            write_pin = Solargraph::Pin::Method.new(
+              location: location,
+              closure: namespace,
+              name: "#{directive.tag.name}=",
+              comments: docstring.all.to_s,
+              scope: namespace.is_a?(Pin::Singleton) ? :class : :instance,
+              visibility: :public,
+              attribute: true,
+              source: :yard_map
+            )
+            new_pins.push(write_pin)
+            write_pin.parameters.push Pin::Parameter.new(name: 'value', decl: :arg, closure: write_pin, source: :yard_map)
+            if write_pin.return_type&.defined?
+              write_pin.docstring.add_tag YARD::Tags::Tag.new(:param, '', write_pin.return_type.to_s.split(', '), 'value')
+            end
+          end
+
+          new_pins.compact
+        end
+
+        # @param [Array<Pin::Base>] pins
+        # @param [Position] position
+        # @return [Pin::Closure]
+        def closure_at pins, position
+          pins.select { |pin| pin.is_a?(Pin::Closure) and pin.location&.range&.contain?(position) }.last
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/yard_map/directives/domain_directive.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class YardMap
+    module Directives
+      module DomainDirective
+        module_function
+
+        # @param source [Solargraph::Source]
+        # @param pins [Array<Solargraph::Pin::Base>]
+        # @param source_position [Position]
+        # @param _comment_position [Position]
+        # @param directive [YARD::Tags::Directive]
+        # @return [Array<Solargraph::Pin::Method>]
+        def process_directive source, pins, source_position, _comment_position, directive
+          namespace = closure_at(pins, source_position) || Pin::ROOT_PIN
+          namespace.domains.concat directive.tag.types unless directive.tag.types.nil?
+          []
+        end
+
+        # @param [Array<Pin::Base>] pins
+        # @param [Position] position
+        # @return [Pin::Namespace]
+        def closure_at pins, position
+          pins.select { |pin| pin.is_a?(Pin::Namespace) and pin.location&.range&.contain?(position) }.last
+        end
+      end
+    end
+  end
+end