solargraph 0.44.3 → 0.49.0

data/lib/solargraph/type_checker.rb

@@ -40,10 +40,12 @@ module Solargraph
     # @return [Array<Problem>]
     def problems
       @problems ||= begin
-        method_tag_problems
-          .concat variable_type_tag_problems
-          .concat const_problems
-          .concat call_problems
+        without_ignored(
+          method_tag_problems
+            .concat variable_type_tag_problems
+            .concat const_problems
+            .concat call_problems
+        )
       end
     end
 
@@ -103,7 +105,7 @@ module Solargraph
               result.push Problem.new(pin.location, "#{pin.path} return type could not be inferred", pin: pin)
             end
           else
-            unless (rules.rank > 1 ? types_match?(api_map, declared, inferred) : any_types_match?(api_map, declared, inferred))
+            unless (rules.rank > 1 ? all_types_match?(api_map, inferred, declared) : any_types_match?(api_map, declared, inferred))
               result.push Problem.new(pin.location, "Declared return type #{declared} does not match inferred type #{inferred} for #{pin.path}", pin: pin)
             end
           end
@@ -118,7 +120,10 @@ module Solargraph
     # @param pin [Pin::Base]
     # @return [Boolean]
     def resolved_constant? pin
-      api_map.get_constants('', pin.binder.tag).any? { |pin| pin.name == pin.return_type.namespace && ['Class', 'Module'].include?(pin.return_type.name) }
+      return true if pin.typify(api_map).defined?
+      api_map.get_constants('', *pin.closure.gates)
+        .select { |p| p.name == pin.return_type.namespace }
+        .any? { |p| p.infer(api_map).defined? }
     end
 
     def virtual_pin? pin
@@ -132,10 +137,12 @@ module Solargraph
       params = first_param_hash(stack)
       result = []
       if rules.require_type_tags?
-        pin.parameters.each do |par|
-          break if par.decl == :restarg || par.decl == :kwrestarg || par.decl == :blockarg
-          unless params[par.name]
-            result.push Problem.new(pin.location, "Missing @param tag for #{par.name} on #{pin.path}", pin: pin)
+        pin.signatures.each do |sig|
+          sig.parameters.each do |par|
+            break if par.decl == :restarg || par.decl == :kwrestarg || par.decl == :blockarg
+            unless params[par.name]
+              result.push Problem.new(pin.location, "Missing @param tag for #{par.name} on #{pin.path}", pin: pin)
+            end
           end
         end
       end
@@ -170,14 +177,14 @@ module Solargraph
                   result.push Problem.new(pin.location, "Variable type could not be inferred for #{pin.name}", pin: pin)
                 end
               else
-                unless (rules.rank > 1 ? types_match?(api_map, declared, inferred) : any_types_match?(api_map, declared, inferred))
+                unless any_types_match?(api_map, declared, inferred)
                   result.push Problem.new(pin.location, "Declared type #{declared} does not match inferred type #{inferred} for variable #{pin.name}", pin: pin)
                 end
               end
             elsif declared_externally?(pin)
               ignored_pins.push pin
             end
-          elsif !pin.is_a?(Pin::Parameter)
+          elsif !pin.is_a?(Pin::Parameter) && !resolved_constant?(pin)
             result.push Problem.new(pin.location, "Unresolved type #{pin.return_type} for variable #{pin.name}", pin: pin)
           end
         else
@@ -235,8 +242,8 @@ module Solargraph
             base = base.base
           end
           closest = found.typify(api_map) if found
-          if !found || (closest.defined? && internal_or_core?(found))
-            unless ignored_pins.include?(found)
+          if !found || found.is_a?(Pin::BaseVariable) || (closest.defined? && internal_or_core?(found))
+            unless closest.parameterized? || ignored_pins.include?(found)
               result.push Problem.new(location, "Unresolved call to #{missing.links.last.word}")
               @marked_ranges.push rng
             end
@@ -266,34 +273,44 @@ module Solargraph
           end
           break unless rules.validate_calls?
           params = first_param_hash(pins)
-          pin.parameters.each_with_index do |par, idx|
-            argchain = base.links.last.arguments[idx]
-            if argchain.nil? && par.decl == :arg
-              result.push Problem.new(location, "Not enough arguments to #{pin.path}")
-              break
-            end
-            if argchain
-              if par.decl != :arg
-                result.concat kwarg_problems_for argchain, api_map, block_pin, locals, location, pin, params, idx
-                break
-              else
-                ptype = params.key?(par.name) ? params[par.name][:qualified] : ComplexType::UNDEFINED
-                if ptype.nil?
-                  # @todo Some level (strong, I guess) should require the param here
+
+          all_errors = []
+          pin.signatures.sort { |sig| sig.parameters.length }.each do |sig|
+            errors = []
+            sig.parameters.each_with_index do |par, idx|
+              argchain = base.links.last.arguments[idx]
+              if argchain.nil? && par.decl == :arg
+                errors.push Problem.new(location, "Not enough arguments to #{pin.path}")
+                next
+              end
+              if argchain
+                if par.decl != :arg
+                  errors.concat kwarg_problems_for argchain, api_map, block_pin, locals, location, pin, params, idx
+                  next
                 else
-                  argtype = argchain.infer(api_map, block_pin, locals)
-                  if argtype.defined? && ptype.defined? && !any_types_match?(api_map, ptype, argtype)
-                    result.push Problem.new(location, "Wrong argument type for #{pin.path}: #{par.name} expected #{ptype}, received #{argtype}")
+                  ptype = params.key?(par.name) ? params[par.name][:qualified] : ComplexType::UNDEFINED
+                  if ptype.nil?
+                    # @todo Some level (strong, I guess) should require the param here
+                  else
+                    argtype = argchain.infer(api_map, block_pin, locals)
+                    if argtype.defined? && ptype.defined? && !any_types_match?(api_map, ptype, argtype)
+                      errors.push Problem.new(location, "Wrong argument type for #{pin.path}: #{par.name} expected #{ptype}, received #{argtype}")
+                      next
+                    end
                   end
                 end
+              elsif par.decl == :kwarg
+                errors.push Problem.new(location, "Call to #{pin.path} is missing keyword argument #{par.name}")
+                next
               end
-            elsif par.rest?
-              next
-            elsif par.decl == :kwarg
-              result.push Problem.new(location, "Call to #{pin.path} is missing keyword argument #{par.name}")
+            end
+            if errors.empty?
+              all_errors.clear
               break
             end
+            all_errors.concat errors
           end
+          result.concat all_errors
         end
         base = base.base
       end
@@ -303,7 +320,7 @@ module Solargraph
     def kwarg_problems_for argchain, api_map, block_pin, locals, location, pin, params, first
       result = []
       kwargs = convert_hash(argchain.node)
-      pin.parameters[first..-1].each_with_index do |par, cur|
+      pin.signatures.first.parameters[first..-1].each_with_index do |par, cur|
         idx = first + cur
         argchain = kwargs[par.name.to_sym]
         if par.decl == :kwrestarg || (par.decl == :optarg && idx == pin.parameters.length - 1 && par.asgn_code == '{}')
@@ -374,8 +391,10 @@ module Solargraph
       pin.location && api_map.bundled?(pin.location.filename)
     end
 
+    # True if the pin is either internal (part of the workspace) or from the core/stdlib
     def internal_or_core? pin
-      internal?(pin) || api_map.yard_map.core_pins.include?(pin) || api_map.yard_map.stdlib_pins.include?(pin)
+      # @todo RBS pins are not necessarily core/stdlib pins
+      internal?(pin) || pin.source == :rbs
     end
 
     # @param pin [Pin::Base]
@@ -410,11 +429,20 @@ module Solargraph
       true
     end
 
-    # @param pin [Pin::Method]
-    def arity_problems_for(pin, arguments, location)
+    def arity_problems_for pin, arguments, location
+      results = pin.signatures.map do |sig|
+        r = parameterized_arity_problems_for(pin, sig.parameters, arguments, location)
+        return [] if r.empty?
+        r
+      end
+      results.first
+    end
+
+    def parameterized_arity_problems_for(pin, parameters, arguments, location)
       return [] unless pin.explicit?
-      return [] if pin.parameters.empty? && arguments.empty?
-      if pin.parameters.empty?
+      return [] if parameters.empty? && arguments.empty?
+      return [] if pin.anon_splat?
+      if parameters.empty?
         # Functions tagged param_tuple accepts two arguments (e.g., Hash#[]=)
         return [] if pin.docstring.tag(:param_tuple) && arguments.length == 2
         return [] if arguments.length == 1 && arguments.last.links.last.is_a?(Source::Chain::BlockVariable)
@@ -422,21 +450,21 @@ module Solargraph
       end
       unchecked = arguments.clone
       add_params = 0
-      if unchecked.empty? && pin.parameters.any? { |param| param.decl == :kwarg }
+      if unchecked.empty? && parameters.any? { |param| param.decl == :kwarg }
         return [Problem.new(location, "Missing keyword arguments to #{pin.path}")]
       end
       settled_kwargs = 0
       unless unchecked.empty?
         if any_splatted_call?(unchecked.map(&:node))
-          settled_kwargs = pin.parameters.count(&:keyword?)
+          settled_kwargs = parameters.count(&:keyword?)
         else
           kwargs = convert_hash(unchecked.last.node)
-          if pin.parameters.any? { |param| [:kwarg, :kwoptarg].include?(param.decl) || param.kwrestarg? }
+          if parameters.any? { |param| [:kwarg, :kwoptarg].include?(param.decl) || param.kwrestarg? }
             if kwargs.empty?
               add_params += 1
             else
               unchecked.pop
-              pin.parameters.each do |param|
+              parameters.each do |param|
                 next unless param.keyword?
                 if kwargs.key?(param.name.to_sym)
                   kwargs.delete param.name.to_sym
@@ -446,7 +474,7 @@ module Solargraph
                   return [Problem.new(location, "Missing keyword argument #{param.name} to #{pin.path}")]
                 end
               end
-              kwargs.clear if pin.parameters.any?(&:kwrestarg?)
+              kwargs.clear if parameters.any?(&:kwrestarg?)
               unless kwargs.empty?
                 return [Problem.new(location, "Unrecognized keyword argument #{kwargs.keys.first} to #{pin.path}")]
               end
@@ -454,18 +482,18 @@ module Solargraph
           end
         end
       end
-      req = required_param_count(pin)
+      req = required_param_count(parameters)
       if req + add_params < unchecked.length
-        return [] if pin.parameters.any?(&:rest?)
-        opt = optional_param_count(pin)
+        return [] if parameters.any?(&:rest?)
+        opt = optional_param_count(parameters)
         return [] if unchecked.length <= req + opt
         if unchecked.length == req + opt + 1 && unchecked.last.links.last.is_a?(Source::Chain::BlockVariable)
           return []
         end
-        if req + add_params + 1 == unchecked.length && any_splatted_call?(unchecked.map(&:node)) && (pin.parameters.map(&:decl) & [:kwarg, :kwoptarg, :kwrestarg]).any?
+        if req + add_params + 1 == unchecked.length && any_splatted_call?(unchecked.map(&:node)) && (parameters.map(&:decl) & [:kwarg, :kwoptarg, :kwrestarg]).any?
           return []
         end
-        return [] if arguments.length - req == pin.parameters.select { |p| [:optarg, :kwoptarg].include?(p.decl) }.length
+        return [] if arguments.length - req == parameters.select { |p| [:optarg, :kwoptarg].include?(p.decl) }.length
         return [Problem.new(location, "Too many arguments to #{pin.path}")]
       elsif unchecked.length < req - settled_kwargs && (arguments.empty? || (!arguments.last.splat? && !arguments.last.links.last.is_a?(Solargraph::Source::Chain::Hash)))
         # HACK: Kernel#raise signature is incorrect in Ruby 2.7 core docs.
@@ -477,19 +505,13 @@ module Solargraph
       []
     end
 
-    # @param pin [Pin::Method]
-    def required_param_count(pin)
-      pin.parameters.sum { |param| %i[arg kwarg].include?(param.decl) ? 1 : 0 }
+    def required_param_count(parameters)
+      parameters.sum { |param| %i[arg kwarg].include?(param.decl) ? 1 : 0 }
     end
 
     # @param pin [Pin::Method]
-    def optional_param_count(pin)
-      count = 0
-      pin.parameters.each do |param|
-        next unless param.decl == :optarg
-        count += 1
-      end
-      count
+    def optional_param_count(parameters)
+      parameters.select { |p| p.decl == :optarg }.length
     end
 
     def abstract? pin
@@ -516,5 +538,12 @@ module Solargraph
       args.push Solargraph::Parser.chain_string('&') if with_block
       args
     end
+
+    def without_ignored problems
+      problems.reject do |problem|
+        node = source_map.source.node_at(problem.location.range.start.line, problem.location.range.start.column)
+        source_map.source.comments_for(node)&.include?('@sg-ignore')
+      end
+    end
   end
 end

data/lib/solargraph/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Solargraph
-  VERSION = '0.44.3'
+  VERSION = '0.49.0'
 end

data/lib/solargraph/views/environment.erb

@@ -30,10 +30,10 @@
       Solargraph Version: <%= Solargraph::VERSION %>
     </li>
     <li>
-      Core Documentation Version: <%= Solargraph::YardMap::CoreDocs.best_match %>
+      Core Documentation Version: N/A <%# @todo Fix %>
     </li>
     <li>
-      Core Cache Directory: <%= Solargraph::YardMap::CoreDocs.cache_dir %>
+      Core Cache Directory: N/A <%# @todo Fix %>
     </li>
     <% unless Solargraph::Parser.rubyvm? %>
       <li>

data/lib/solargraph/workspace.rb

@@ -2,6 +2,7 @@
 
 require 'open3'
 require 'rubygems'
+require 'json'
 
 module Solargraph
   # A workspace consists of the files in a project's directory and the
@@ -45,24 +46,21 @@ module Solargraph
     #
     # @param source [Solargraph::Source]
     # @return [Boolean] True if the source was added to the workspace
-    def merge source
-      unless directory == '*' || source_hash.key?(source.filename)
+    def merge *sources
+      unless directory == '*' || sources.all? { |source| source_hash.key?(source.filename) }
         # Reload the config to determine if a new source should be included
         @config = Solargraph::Workspace::Config.new(directory)
-        return false unless config.calculated.include?(source.filename)
       end
-      source_hash[source.filename] = source
-      true
-    end
 
-    # Determine whether a file would be merged into the workspace.
-    #
-    # @param filename [String]
-    # @return [Boolean]
-    def would_merge? filename
-      return true if directory == '*' || source_hash.include?(filename)
-      @config = Solargraph::Workspace::Config.new(directory)
-      config.calculated.include?(filename)
+      includes_any = false
+      sources.each do |source|
+        if directory == "*" || config.calculated.include?(source.filename)
+          source_hash[source.filename] = source
+          includes_any = true
+        end
+      end
+
+      includes_any
     end
 
     # Remove a source from the workspace. The source will not be removed if

data/lib/solargraph/yard_map/mapper/to_method.rb

@@ -13,16 +13,19 @@ module Solargraph
           )
           location = object_location(code_object, spec)
           comments = code_object.docstring ? code_object.docstring.all.to_s : ''
-          Pin::Method.new(
+          pin = Pin::Method.new(
             location: location,
             closure: closure,
             name: name || code_object.name.to_s,
             comments: comments,
             scope: scope || code_object.scope,
             visibility: visibility || code_object.visibility,
-            parameters: get_parameters(code_object, location, comments),
+            # @todo Might need to convert overloads to signatures
+            parameters: [],
             explicit: code_object.is_explicit?
           )
+          pin.parameters.concat get_parameters(code_object, location, comments, pin)
+          pin
         end
 
         class << self
@@ -30,7 +33,7 @@ module Solargraph
 
           # @param code_object [YARD::CodeObjects::Base]
           # @return [Array<Solargraph::Pin::Parameter>]
-          def get_parameters code_object, location, comments
+          def get_parameters code_object, location, comments, pin
             return [] unless code_object.is_a?(YARD::CodeObjects::MethodObject)
             # HACK: Skip `nil` and `self` parameters that are sometimes emitted
             # for methods defined in C
@@ -38,7 +41,7 @@ module Solargraph
             code_object.parameters.select { |a| a[0] && a[0] != 'self' }.map do |a|
               Solargraph::Pin::Parameter.new(
                 location: location,
-                closure: self,
+                closure: pin,
                 comments: comments,
                 name: arg_name(a),
                 presence: nil,