solargraph 0.45.0 → 0.49.0

data/lib/solargraph/shell.rb

@@ -71,43 +71,47 @@ module Solargraph
       STDOUT.puts "Configuration file initialized."
     end
 
-    desc 'download-core [VERSION]', 'Download core documentation'
-    def download_core version = nil
-      ver = version || Solargraph::YardMap::CoreDocs.best_download
-      if RUBY_VERSION != ver
-        puts "Documentation for #{RUBY_VERSION} is not available. Reverting to closest match..."
-      end
-      puts "Downloading docs for #{ver}..."
-      Solargraph::YardMap::CoreDocs.download ver
-      # Clear cached documentation if it exists
-      FileUtils.rm_rf Dir.glob(File.join(Solargraph::YardMap::CoreDocs.cache_dir, ver, '*.ser'))
-      puts "Download complete."
-    rescue ArgumentError => e
-      STDERR.puts "ERROR: #{e.message}"
-      STDERR.puts "Run `solargraph available-cores` for a list."
-      exit 1
+    desc 'download-core [VERSION]', 'Download core documentation [deprecated]'
+    long_desc %(
+      The `download-core` command is deprecated. Current versions of Solargraph
+      use RBS for core and stdlib documentation.
+    )
+    # @deprecated
+    def download_core _version = nil
+      puts 'The `download-core` command is deprecated.'
+      puts 'Current versions of Solargraph use RBS for core and stdlib documentation.'
     end
 
-    desc 'list-cores', 'List the local documentation versions'
+    desc 'list-cores', 'List the local documentation versions [deprecated]'
+    long_desc %(
+      The `list-cores` command is deprecated. Current versions of Solargraph use
+      RBS for core and stdlib documentation.
+    )
+    # @deprecated
     def list_cores
-      puts Solargraph::YardMap::CoreDocs.versions.join("\n")
+      puts 'The `list-cores` command is deprecated.'
+      puts 'Current versions of Solargraph use RBS for core and stdlib documentation.'
     end
 
-    desc 'available-cores', 'List available documentation versions'
+    desc 'available-cores', 'List available documentation versions [deprecated]'
+    long_desc %(
+      The `available-cores` command is deprecated. Current versions of Solargraph
+      use RBS for core and stdlib documentation.
+    )
+    # @deprecated
     def available_cores
-      puts Solargraph::YardMap::CoreDocs.available.join("\n")
+      puts 'The `available-cores` command is deprecated.'
+      puts 'Current versions of Solargraph use RBS for core and stdlib documentation.'
     end
 
     desc 'clear', 'Delete all cached documentation'
     long_desc %(
       This command will delete all core and gem documentation from the cache.
-      You can also delete specific gem caches with the `uncache` command or
-      update documentation for specific Ruby versions with the `download-core`
-      command.
     )
+    # @deprecated
     def clear
       puts "Deleting the cached documentation"
-      Solargraph::YardMap::CoreDocs.clear
+      Solargraph::Cache.clear
     end
     map 'clear-cache' => :clear
     map 'clear-cores' => :clear
@@ -191,18 +195,22 @@ module Solargraph
       puts "Scanned #{directory} (#{api_map.pins.length} pins) in #{time.real} seconds."
     end
 
-    desc 'bundle', 'Generate documentation for bundled gems'
+    desc 'bundle', 'Generate documentation for bundled gems [deprecated]'
+    long_desc %(
+      The `bundle` command is deprecated. Solargraph currently uses RBS instead.
+    )
     option :directory, type: :string, aliases: :d, desc: 'The workspace directory', default: '.'
     option :rebuild, type: :boolean, aliases: :r, desc: 'Rebuild existing documentation', default: false
     def bundle
-      Documentor.new(options[:directory], rebuild: options[:rebuild], out: STDOUT).document
+      puts 'The `bundle` command is deprecated. Solargraph currently uses RBS instead.'
     end
 
-    desc 'rdoc GEM [VERSION]', 'Use RDoc to cache documentation'
-    def rdoc gem, version = '>= 0'
-      spec = Gem::Specification.find_by_name(gem, version)
-      puts "Caching #{spec.name} #{spec.version} from RDoc"
-      Solargraph::YardMap::RdocToYard.run(spec)
+    desc 'rdoc GEM [VERSION]', 'Use RDoc to cache documentation [deprecated]'
+    long_desc %(
+      The `rdoc` command is deprecated. Solargraph currently uses RBS instead.
+    )
+    def rdoc _gem, _version = '>= 0'
+      puts 'The `rdoc` command is deprecated. Solargraph currently uses RBS instead.'
     end
 
     private

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

@@ -35,7 +35,10 @@ module Solargraph
             []
           end
           return inferred_pins(found, api_map, name_pin.context, locals) unless found.empty?
-          pins = api_map.get_method_stack(name_pin.binder.namespace, word, scope: name_pin.binder.scope)
+          # @param [ComplexType::UniqueType]
+          pins = name_pin.binder.each_unique_type.flat_map do |context|
+            api_map.get_method_stack(context.namespace, word, scope: context.scope)
+          end
           return [] if pins.empty?
           inferred_pins(pins, api_map, name_pin.context, locals)
         end
@@ -49,36 +52,32 @@ module Solargraph
         # @return [Array<Pin::Base>]
         def inferred_pins pins, api_map, context, locals
           result = pins.map do |p|
-            overloads = p.docstring.tags(:overload)
+            next p unless p.is_a?(Pin::Method)
+            overloads = p.signatures
             # next p if overloads.empty?
             type = ComplexType::UNDEFINED
-            # @param [YARD::Tags::OverloadTag]
             overloads.each do |ol|
-              next unless arguments_match(arguments, ol.parameters)
-              next if ol.parameters.last && ol.parameters.last.first.start_with?('&') && ol.parameters.last.last.nil? && !with_block?
+              next unless arguments_match(arguments, ol)
+              # next if ol.parameters.last && ol.parameters.last.first.start_with?('&') && ol.parameters.last.last.nil? && !with_block?
               match = true
               arguments.each_with_index do |arg, idx|
-                achain = arguments[idx]
-                next if achain.nil?
                 param = ol.parameters[idx]
                 if param.nil?
-                  match = false unless ol.parameters.last && ol.parameters.last.first.start_with?('*')
+                  match = false unless ol.parameters.any?(&:restarg?)
                   break
                 end
-                par = ol.tags(:param).select { |pp| pp.name == param.first }.first
-                next if par.nil? || par.types.nil? || par.types.empty?
-                atype = achain.infer(api_map, Pin::ProxyType.anonymous(context), locals)
-                other = ComplexType.try_parse(*par.types)
+                atype = arg.infer(api_map, Pin::ProxyType.anonymous(context), locals)
                 # @todo Weak type comparison
-                unless atype.tag == other.tag || api_map.super_and_sub?(other.tag, atype.tag)
+                # unless atype.tag == param.return_type.tag || api_map.super_and_sub?(param.return_type.tag, atype.tag)
+                unless param.return_type.undefined? || atype.name == param.return_type.name || api_map.super_and_sub?(param.return_type.name, atype.name)
                   match = false
                   break
                 end
               end
               if match
-                type = extra_return_type(ol, context)
+                type = extra_return_type(p.docstring, context)
                 break if type
-                type = ComplexType.try_parse(*ol.tag(:return).types).self_to(context.to_s).qualify(api_map, context.namespace) if ol.has_tag?(:return) && ol.tag(:return).types && !ol.tag(:return).types.empty? && (type.nil? || type.undefined?)
+                type = with_params(ol.return_type.self_to(context.to_s), context).qualify(api_map, context.namespace) if ol.return_type.defined?
                 type ||= ComplexType::UNDEFINED
               end
               break if type.defined?
@@ -107,9 +106,13 @@ module Solargraph
             p
           end
           result.map do |pin|
-            next pin if pin.return_type.undefined?
-            selfy = pin.return_type.self_to(context.tag)
-            selfy == pin.return_type ? pin : pin.proxy(selfy)
+            if pin.path == 'Class#new' && context.tag != 'Class'
+              pin.proxy(ComplexType.try_parse(context.namespace))
+            else
+              next pin if pin.return_type.undefined?
+              selfy = pin.return_type.self_to(context.tag)
+              selfy == pin.return_type ? pin : pin.proxy(selfy)
+            end
           end
         end
 
@@ -180,14 +183,15 @@ module Solargraph
         end
 
         # @param arguments [Array<Chain>]
-        # @param parameters [Array<String>]
+        # @param signature [Pin::Signature]
         # @return [Boolean]
-        def arguments_match arguments, parameters
+        def arguments_match arguments, signature
+          parameters = signature.parameters
           argcount = arguments.length
-          # argcount -= 1 if !arguments.empty? && arguments.last.links.first.word.start_with?('&')
           parcount = parameters.length
-          parcount -= 1 if !parameters.empty? && parameters.last.first.start_with?('&')
-          return false if argcount < parcount && !(argcount == parcount - 1 && parameters.last.first.start_with?('*'))
+          parcount -= 1 if !parameters.empty? && parameters.last.block?
+          return false if signature.block? && !with_block?
+          return false if argcount < parcount && !(argcount == parcount - 1 && parameters.last.restarg?)
           true
         end
 
@@ -198,6 +202,13 @@ module Solargraph
           pins = api_map.get_method_stack(name_pin.namespace, name_pin.name, scope: name_pin.scope)
           pins.reject{|p| p.path == name_pin.path}
         end
+
+        # @param type [ComplexType]
+        # @param context [ComplexType]
+        def with_params type, context
+          return type unless type.to_s.include?('$')
+          ComplexType.try_parse(type.to_s.gsub('$', context.value_types.map(&:tag).join(', ')).gsub('<>', ''))
+        end
       end
     end
   end

data/lib/solargraph/source/chain.rb

@@ -63,11 +63,11 @@ module Solargraph
         working_pin = name_pin
         links[0..-2].each do |link|
           pins = link.resolve(api_map, working_pin, locals)
-          type = infer_first_defined(pins, working_pin, api_map)
+          type = infer_first_defined(pins, working_pin, api_map, locals)
           return [] if type.undefined?
           working_pin = Pin::ProxyType.anonymous(type)
         end
-        links.last.last_context = working_pin
+        links.last.last_context = name_pin
         links.last.resolve(api_map, working_pin, locals)
       end
 
@@ -76,8 +76,12 @@ module Solargraph
       # @param locals [Array<Pin::Base>]
       # @return [ComplexType]
       def infer api_map, name_pin, locals
+        from_here = base.infer(api_map, name_pin, locals) unless links.length == 1
+        if from_here
+          name_pin = name_pin.proxy(from_here)
+        end
         pins = define(api_map, name_pin, locals)
-        type = infer_first_defined(pins, links.last.last_context, api_map)
+        type = infer_first_defined(pins, links.last.last_context, api_map, locals)
         maybe_nil(type)
       end
 
@@ -110,9 +114,10 @@ module Solargraph
       private
 
       # @param pins [Array<Pin::Base>]
+      # @param context [Pin::Base]
       # @param api_map [ApiMap]
       # @return [ComplexType]
-      def infer_first_defined pins, context, api_map
+      def infer_first_defined pins, context, api_map, locals
         possibles = []
         pins.each do |pin|
           # Avoid infinite recursion
@@ -121,8 +126,18 @@ module Solargraph
           type = pin.typify(api_map)
           @@inference_stack.pop
           if type.defined?
-            possibles.push type
-            break if pin.is_a?(Pin::Method)
+            if type.parameterized?
+              type = type.resolve_parameters(pin.closure, context)
+              # idx = pin.closure.parameters.index(type.subtypes.first.name)
+              # next if idx.nil?
+              # param_type = context.return_type.all_params[idx]
+              # next unless param_type
+              # type = ComplexType.try_parse(param_type.to_s)
+            end
+            if type.defined?
+              possibles.push type
+              break if pin.is_a?(Pin::Method)
+            end
           end
         end
         if possibles.empty?

data/lib/solargraph/source.rb

@@ -360,7 +360,7 @@ module Solargraph
       skip = nil
       comments.lines.each { |l|
         # Trim the comment and minimum leading whitespace
-        p = l.encode('UTF-8', invalid: :replace, replace: '?').gsub(/^#+/, '')
+        p = l.force_encoding('UTF-8').encode('UTF-8', invalid: :replace, replace: '?').gsub(/^#+/, '')
         if p.strip.empty?
           next unless started
           ctxt.concat p

data/lib/solargraph/source_map/clip.rb

@@ -43,6 +43,11 @@ module Solargraph
       # @return [ComplexType]
       def infer
         result = cursor.chain.infer(api_map, block, locals)
+        if result.tag == 'Class'
+          # HACK: Exception to return Object from Class#new
+          dfn = cursor.chain.define(api_map, block, locals).first
+          return ComplexType.try_parse('Object') if dfn && dfn.path == 'Class#new'
+        end
         return result unless result.tag == 'self'
         ComplexType.try_parse(cursor.chain.base.infer(api_map, block, locals).namespace)
       end

data/lib/solargraph/source_map/mapper.rb

@@ -12,7 +12,7 @@ module Solargraph
 
       private_class_method :new
 
-      MACRO_REGEXP = /(@\!method|@\!attribute|@\!domain|@\!macro|@\!parse|@\!override)/.freeze
+      MACRO_REGEXP = /(@\!method|@\!attribute|@\!visibility|@\!domain|@\!macro|@\!parse|@\!override)/.freeze
 
       # Generate the data.
       #
@@ -24,6 +24,8 @@ module Solargraph
         @code = source.code
         @comments = source.comments
         @pins, @locals = Parser.map(source)
+        @pins.each { |p| p.source = :code }
+        @locals.each { |l| l.source = :code }
         process_comment_directives
         [@pins, @locals]
       # rescue Exception => e
@@ -56,8 +58,10 @@ module Solargraph
         @pins ||= []
       end
 
+      # @param position [Solargraph::Position]
+      # @return [Solargraph::Pin::Closure]
       def closure_at(position)
-        @pins.select{|pin| pin.is_a?(Pin::Closure) and pin.location.range.contain?(position)}.last
+        pins.select{|pin| pin.is_a?(Pin::Closure) and pin.location.range.contain?(position)}.last
       end
 
       def process_comment source_position, comment_position, comment
@@ -147,6 +151,27 @@ module Solargraph
               pins.last.docstring.add_tag YARD::Tags::Tag.new(:param, '', pins.last.return_type.to_s.split(', '), 'value')
             end
           end
+        when 'visibility'
+          begin
+            kind = directive.tag.text&.to_sym
+            return unless [:private, :protected, :public].include?(kind)
+
+            name = directive.tag.name
+            closure = closure_at(source_position) || @pins.first
+            if closure.location.range.start.line < comment_position.line
+              closure = closure_at(comment_position)
+            end
+            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{ |pin| pin.is_a?(Pin::Method) && pin.name == name && pin.namespace == namespace && pin.context.scope == namespace.is_a?(Pin::Singleton) ? :class : :instance }
+              matches.each do |pin|
+                # @todo Smelly instance variable access
+                pin.instance_variable_set(:@visibility, kind)
+              end
+            end
+          end
         when 'parse'
           begin
             ns = closure_at(source_position)
@@ -176,6 +201,10 @@ module Solargraph
         end
       end
 
+      def no_empty_lines?(line1, line2)
+        @code.lines[line1..line2].none? { |line| line.strip.empty? }
+      end
+
       def remove_inline_comment_hashes comment
         ctxt = ''
         num = nil

data/lib/solargraph/source_map.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'jaro_winkler'
 require 'yard'
 require 'yard-solargraph'
 require 'set'
@@ -76,8 +75,7 @@ module Solargraph
     # @param query [String]
     # @return [Array<Pin::Base>]
     def query_symbols query
-      return document_symbols if query && query.empty?
-      document_symbols.select{ |pin| fuzzy_string_match(pin.path, query) || fuzzy_string_match(pin.name, query) }
+      Pin::Search.new(document_symbols, query).results
     end
 
     # @param position [Position]
@@ -178,12 +176,5 @@ module Solargraph
       # Assuming the root pin is always valid
       found || pins.first
     end
-
-    # @param str1 [String]
-    # @param str2 [String]
-    # @return [Boolean]
-    def fuzzy_string_match str1, str2
-      JaroWinkler.distance(str1, str2) > 0.6
-    end
   end
 end

data/lib/solargraph/type_checker/checks.rb

@@ -61,6 +61,19 @@ module Solargraph
         false
       end
 
+      # @param api_map [ApiMap]
+      # @param inferred [ComplexType]
+      # @param expected [ComplexType]
+      # @return [Boolean]
+      def all_types_match? api_map, inferred, expected
+        return duck_types_match?(api_map, expected, inferred) if expected.duck_type?
+        inferred.each do |inf|
+          next if inf.duck_type?
+          return false unless expected.any? { |exp| exp == inf || either_way?(api_map, inf, exp) }
+        end
+        true
+      end
+
       # @param api_map [ApiMap]
       # @param expected [ComplexType]
       # @param inferred [ComplexType]