solargraph 0.59.1 → 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"
@@ -188,7 +190,7 @@ module Solargraph
         names.each do |name|
           if name == 'core'
             # @sg-ignore cache_core and core? are dynamically defined
-            PinCache.cache_core(out: $stdout) if !PinCache.core? || options[:rebuild]
+            PinCache.cache_core(out: $stdout) # if !PinCache.core? || options[:rebuild]
             next
           end
 
@@ -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/array.rb

@@ -19,18 +19,7 @@ module Solargraph
         # @param name_pin [Pin::Base]
         # @param locals [::Array<Pin::Parameter, Pin::LocalVariable>]
         def resolve api_map, name_pin, locals
-          child_types = @children.map do |child|
-            child.infer(api_map, name_pin, locals).simplify_literals
-          end
-          type = if child_types.empty? || child_types.any?(&:undefined?)
-                   ComplexType::UniqueType.new('Array', rooted: true)
-                 elsif child_types.uniq.length == 1 && child_types.first.defined?
-                   ComplexType::UniqueType.new('Array', [], child_types.uniq, rooted: true, parameters_type: :list)
-                 elsif child_types.empty?
-                   ComplexType::UniqueType.new('Array', rooted: true, parameters_type: :list)
-                 else
-                   ComplexType::UniqueType.new('Array', [], child_types, rooted: true, parameters_type: :fixed)
-                 end
+          type = ComplexType::UniqueType.new('Array', rooted: true)
           [Pin::ProxyType.anonymous(type, source: :chain)]
         end
       end

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

@@ -1,13 +1,13 @@
-# frozen_string_literal: true
-
-module Solargraph
-  class Source
-    class Chain
-      class BlockSymbol < Link
-        def resolve api_map, name_pin, locals
-          [Pin::ProxyType.anonymous(ComplexType.try_parse('::Proc'), source: :chain)]
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  class Source
+    class Chain
+      class BlockSymbol < Link
+        def resolve api_map, name_pin, locals
+          [Pin::ProxyType.anonymous(ComplexType.try_parse('::Proc'), source: :chain)]
+        end
+      end
+    end
+  end
+end

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

@@ -1,13 +1,13 @@
-# frozen_string_literal: true
-
-module Solargraph
-  class Source
-    class Chain
-      class BlockVariable < Link
-        def resolve api_map, name_pin, locals
-          [Pin::ProxyType.anonymous(ComplexType.try_parse('::Proc'), source: :chain)]
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  class Source
+    class Chain
+      class BlockVariable < Link
+        def resolve api_map, name_pin, locals
+          [Pin::ProxyType.anonymous(ComplexType.try_parse('::Proc'), source: :chain)]
+        end
+      end
+    end
+  end
+end

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/chain/head.rb

@@ -1,19 +1,19 @@
-# frozen_string_literal: true
-
-module Solargraph
-  class Source
-    class Chain
-      # Chain::Head is a link for ambiguous words, e.g.; `String` can refer to
-      # either a class (`String`) or a function (`Kernel#String`).
-      #
-      # @note Chain::Head is only intended to handle `self` and `super`.
-      class Head < Link
-        def resolve api_map, name_pin, locals
-          return [Pin::ProxyType.anonymous(name_pin.binder, source: :chain)] if word == 'self'
-          # return super_pins(api_map, name_pin) if word == 'super'
-          []
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  class Source
+    class Chain
+      # Chain::Head is a link for ambiguous words, e.g.; `String` can refer to
+      # either a class (`String`) or a function (`Kernel#String`).
+      #
+      # @note Chain::Head is only intended to handle `self` and `super`.
+      class Head < Link
+        def resolve api_map, name_pin, locals
+          return [Pin::ProxyType.anonymous(name_pin.binder, source: :chain)] if word == 'self'
+          # return super_pins(api_map, name_pin) if word == 'super'
+          []
+        end
+      end
+    end
+  end
+end

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

@@ -13,21 +13,25 @@ module Solargraph
         def initialize type, node
           super("<#{type}>")
 
-          if node.is_a?(::Parser::AST::Node)
-            # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
-            if node.type == :true
-              @value = true
-            # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
-            elsif node.type == :false
-              @value = false
-            # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
-            elsif %i[int sym].include?(node.type)
-              # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
-              @value = node.children.first
-            end
-          end
+          # @todo We might be able to do some light inference from literals and
+          #   tuples as long as literal values are intransitive.
+
+          # if node.is_a?(::Parser::AST::Node)
+          #   # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
+          #   if node.type == :true
+          #     @value = true
+          #   # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
+          #   elsif node.type == :false
+          #     @value = false
+          #   # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
+          #   elsif %i[int sym].include?(node.type)
+          #     # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
+          #     @value = node.children.first
+          #   end
+          # end
           @type = type
-          @literal_type = ComplexType.try_parse(@value.inspect)
+          # @literal_type = ComplexType.try_parse(@value.inspect)
+          @literal_type = ComplexType::UNDEFINED
           @complex_type = ComplexType.try_parse(type)
         end
 

data/lib/solargraph/source/source_chainer.rb

@@ -32,10 +32,10 @@ module Solargraph
       # @return [Source::Chain]
       def chain
         # Special handling for files that end with an integer and a period
-        if phrase =~ /^[0-9]+\.$/
-          return Chain.new([Chain::Literal.new('Integer', Integer(phrase[0..-2])),
-                            Chain::UNDEFINED_CALL])
-        end
+        # if phrase =~ /^[0-9]+\.$/
+        #   return Chain.new([Chain::Literal.new('Integer', Integer(phrase[0..-2])),
+        #                     Chain::UNDEFINED_CALL])
+        # end
         if phrase.start_with?(':') && !phrase.start_with?('::')
           return Chain.new([Chain::Literal.new('Symbol',
                                                # @sg-ignore Need to add nil check here