solargraph 0.56.0 → 0.57.0

data/lib/solargraph/source_map.rb

@@ -21,6 +21,11 @@ module Solargraph
       data.pins
     end
 
+    # @return [Array<Pin::Base>]
+    def all_pins
+      pins + convention_pins
+    end
+
     # @return [Array<Pin::LocalVariable>]
     def locals
       data.locals
@@ -30,13 +35,18 @@ module Solargraph
     def initialize source
       @source = source
 
-      environ.merge Convention.for_local(self) unless filename.nil?
-      self.convention_pins = environ.pins
+      conventions_environ.merge Convention.for_local(self) unless filename.nil?
+      # FIXME: unmemoizing the document_symbols in case it was called and memoized from any of conventions above
+      # this is to ensure that the convention_pins from all conventions are used in the document_symbols.
+      # solargraph-rails is known to use this method to get the document symbols. It should probably be removed.
+      @document_symbols = nil
+      self.convention_pins = conventions_environ.pins
       @pin_select_cache = {}
     end
 
-    # @param klass [Class]
-    # @return [Array<Pin::Base>]
+    # @generic T
+    # @param klass [Class<generic<T>>]
+    # @return [Array<generic<T>>]
     def pins_by_class klass
       @pin_select_cache[klass] ||= pin_class_hash.select { |key, _| key <= klass }.values.flatten
     end
@@ -67,8 +77,8 @@ module Solargraph
     end
 
     # @return [Environ]
-    def environ
-      @environ ||= Environ.new
+    def conventions_environ
+      @conventions_environ ||= Environ.new
     end
 
     # all pins except Solargraph::Pin::Reference::Reference
@@ -158,10 +168,15 @@ module Solargraph
 
     private
 
+    # @return [Hash{Class => Array<Pin::Base>}]
+    # @return [Array<Pin::Base>]
+    attr_writer :convention_pins
+
     def pin_class_hash
       @pin_class_hash ||= pins.to_set.classify(&:class).transform_values(&:to_a)
     end
 
+    # @return [Data]
     def data
       @data ||= Data.new(source)
     end
@@ -171,14 +186,6 @@ module Solargraph
       @convention_pins || []
     end
 
-    # @param pins [Array<Pin::Base>]
-    # @return [Array<Pin::Base>]
-    def convention_pins=(pins)
-      # unmemoizing the document_symbols in case it was called from any of conventions
-      @document_symbols = nil
-      @convention_pins = pins
-    end
-
     # @param line [Integer]
     # @param character [Integer]
     # @param klasses [Array<Class>]

data/lib/solargraph/type_checker/param_def.rb

@@ -12,6 +12,8 @@ module Solargraph
       # @return [Symbol]
       attr_reader :type
 
+      # @param name [String]
+      # @param type [Symbol] The type of parameter, such as :req, :opt, :rest, etc.
       def initialize name, type
         @name = name
         @type = type

data/lib/solargraph/type_checker/rules.rb

@@ -57,6 +57,14 @@ module Solargraph
       def require_all_return_types_match_inferred?
         rank >= LEVELS[:alpha]
       end
+
+      # We keep this at strong because if you added an @ sg-ignore to
+      # address a strong-level issue, then ran at a lower level, you'd
+      # get a false positive - we don't run stronger level checks than
+      # requested for performance reasons
+      def validate_sg_ignores?
+        rank >= LEVELS[:strong]
+      end
     end
   end
 end

data/lib/solargraph/type_checker.rb

@@ -38,15 +38,20 @@ module Solargraph
       @source_map ||= api_map.source_map(filename)
     end
 
+    # @return [Source]
+    def source
+      @source_map.source
+    end
+
     # @return [Array<Problem>]
     def problems
       @problems ||= begin
-        without_ignored(
-          method_tag_problems
-            .concat variable_type_tag_problems
-            .concat const_problems
-            .concat call_problems
-        )
+         all = method_tag_problems
+                 .concat(variable_type_tag_problems)
+                 .concat(const_problems)
+                 .concat(call_problems)
+         unignored = without_ignored(all)
+         unignored.concat(unneeded_sgignore_problems)
       end
     end
 
@@ -140,7 +145,7 @@ module Solargraph
 
     # @param pin [Pin::Base]
     def virtual_pin? pin
-      pin.location && source_map.source.comment_at?(pin.location.range.ending)
+      pin.location && source.comment_at?(pin.location.range.ending)
     end
 
     # @param pin [Pin::Method]
@@ -231,7 +236,7 @@ module Solargraph
     def const_problems
       return [] unless rules.validate_consts?
       result = []
-      Solargraph::Parser::NodeMethods.const_nodes_from(source_map.source.node).each do |const|
+      Solargraph::Parser::NodeMethods.const_nodes_from(source.node).each do |const|
         rng = Solargraph::Range.from_node(const)
         chain = Solargraph::Parser.chain(const, filename)
         block_pin = source_map.locate_block_pin(rng.start.line, rng.start.column)
@@ -249,7 +254,7 @@ module Solargraph
     # @return [Array<Problem>]
     def call_problems
       result = []
-      Solargraph::Parser::NodeMethods.call_nodes_from(source_map.source.node).each do |call|
+      Solargraph::Parser::NodeMethods.call_nodes_from(source.node).each do |call|
         rng = Solargraph::Range.from_node(call)
         next if @marked_ranges.any? { |d| d.contain?(rng.start) }
         chain = Solargraph::Parser.chain(call, filename)
@@ -272,7 +277,11 @@ module Solargraph
           # @todo remove the internal_or_core? check at a higher-than-strict level
           if !found || found.is_a?(Pin::BaseVariable) || (closest.defined? && internal_or_core?(found))
             unless closest.generic? || ignored_pins.include?(found)
-              result.push Problem.new(location, "Unresolved call to #{missing.links.last.word}")
+              if closest.defined?
+                result.push Problem.new(location, "Unresolved call to #{missing.links.last.word} on #{closest}")
+              else
+                result.push Problem.new(location, "Unresolved call to #{missing.links.last.word}")
+              end
               @marked_ranges.push rng
             end
           end
@@ -284,127 +293,136 @@ module Solargraph
 
     # @param chain [Solargraph::Source::Chain]
     # @param api_map [Solargraph::ApiMap]
-    # @param block_pin [Solargraph::Pin::Base]
+    # @param closure_pin [Solargraph::Pin::Closure]
     # @param locals [Array<Solargraph::Pin::Base>]
     # @param location [Solargraph::Location]
     # @return [Array<Problem>]
-    def argument_problems_for chain, api_map, block_pin, locals, location
+    def argument_problems_for chain, api_map, closure_pin, locals, location
       result = []
       base = chain
-      until base.links.length == 1 && base.undefined?
-        last_base_link = base.links.last
-        break unless last_base_link.is_a?(Solargraph::Source::Chain::Call)
-
-        arguments = last_base_link.arguments
-
-        pins = base.define(api_map, block_pin, locals)
-
-        first_pin = pins.first
-        if first_pin.is_a?(Pin::DelegatedMethod) && !first_pin.resolvable?(api_map)
-          # Do nothing, as we can't find the actual method implementation
-        elsif first_pin.is_a?(Pin::Method)
-          # @type [Pin::Method]
-          pin = first_pin
-          ap = if base.links.last.is_a?(Solargraph::Source::Chain::ZSuper)
-            arity_problems_for(pin, fake_args_for(block_pin), location)
-          elsif pin.path == 'Class#new'
-            fqns = if base.links.one?
-              block_pin.namespace
+      # @type last_base_link [Solargraph::Source::Chain::Call]
+      last_base_link = base.links.last
+      return [] unless last_base_link.is_a?(Solargraph::Source::Chain::Call)
+
+      arguments = last_base_link.arguments
+
+      pins = base.define(api_map, closure_pin, locals)
+
+      first_pin = pins.first
+      unresolvable = first_pin.is_a?(Pin::DelegatedMethod) && !first_pin.resolvable?(api_map)
+      if !unresolvable && first_pin.is_a?(Pin::Method)
+        # @type [Pin::Method]
+        pin = first_pin
+        ap = if base.links.last.is_a?(Solargraph::Source::Chain::ZSuper)
+               arity_problems_for(pin, fake_args_for(closure_pin), location)
+             elsif pin.path == 'Class#new'
+               fqns = if base.links.one?
+                        closure_pin.namespace
+                      else
+                        base.base.infer(api_map, closure_pin, locals).namespace
+                      end
+               init = api_map.get_method_stack(fqns, 'initialize').first
+
+               init ? arity_problems_for(init, arguments, location) : []
+             else
+               arity_problems_for(pin, arguments, location)
+             end
+        return ap unless ap.empty?
+        return [] if !rules.validate_calls? || base.links.first.is_a?(Solargraph::Source::Chain::ZSuper)
+
+        params = first_param_hash(pins)
+
+        all_errors = []
+        pin.signatures.sort { |sig| sig.parameters.length }.each do |sig|
+          signature_errors = signature_argument_problems_for location, locals, closure_pin, params, arguments, sig, pin
+          if signature_errors.empty?
+            # we found a signature that works - meaning errors from
+            # other signatures don't matter.
+            return []
+          end
+          all_errors.concat signature_errors
+        end
+        result.concat all_errors
+      end
+      result
+    end
+
+    # @param location [Location]
+    # @param locals [Array<Pin::LocalVariable>]
+    # @param closure_pin [Pin::Closure]
+    # @param params [Hash{String => Hash{Symbol => String, Solargraph::ComplexType}}]
+    # @param arguments [Array<Source::Chain>]
+    # @param sig [Pin::Signature]
+    # @param pin [Pin::Method]
+    # @param pins [Array<Pin::Method>]
+    #
+    # @return [Array<Problem>]
+    def signature_argument_problems_for location, locals, closure_pin, params, arguments, sig, pin
+      errors = []
+      # @todo add logic mapping up restarg parameters with
+      #   arguments (including restarg arguments).  Use tuples
+      #   when possible, and when not, ensure provably
+      #   incorrect situations are detected.
+      sig.parameters.each_with_index do |par, idx|
+        return errors if par.decl == :restarg  # bail out and assume the rest is valid pending better arg processing
+        argchain = arguments[idx]
+        if argchain.nil?
+          if par.decl == :arg
+            final_arg = arguments.last
+            if final_arg && final_arg.node.type == :splat
+              argchain = final_arg
+              return errors
             else
-              base.base.infer(api_map, block_pin, locals).namespace
+              errors.push Problem.new(location, "Not enough arguments to #{pin.path}")
             end
-            init = api_map.get_method_stack(fqns, 'initialize').first
-            init ? arity_problems_for(init, arguments, location) : []
           else
-            arity_problems_for(pin, arguments, location)
-          end
-          unless ap.empty?
-            result.concat ap
-            break
+            final_arg = arguments.last
+            argchain = final_arg if final_arg && [:kwsplat, :hash].include?(final_arg.node.type)
           end
-          break if !rules.validate_calls? || base.links.first.is_a?(Solargraph::Source::Chain::ZSuper)
-
-          params = first_param_hash(pins)
-
-          all_errors = []
-          pin.signatures.sort { |sig| sig.parameters.length }.each do |sig|
-            errors = []
-            sig.parameters.each_with_index do |par, idx|
-              # @todo add logic mapping up restarg parameters with
-              #   arguments (including restarg arguments).  Use tuples
-              #   when possible, and when not, ensure provably
-              #   incorrect situations are detected.
-              break if par.decl == :restarg  # bail out pending better arg processing
-              argchain = arguments[idx]
-              if argchain.nil?
-                if par.decl == :arg
-                  final_arg = arguments.last
-                  if final_arg && final_arg.node.type == :splat
-                    argchain = final_arg
-                    next # don't try to apply the type of the splat - unlikely to be specific enough
-                  else
-                    errors.push Problem.new(location, "Not enough arguments to #{pin.path}")
-                    next
-                  end
-                else
-                  final_arg = arguments.last
-                  argchain = final_arg if final_arg && [:kwsplat, :hash].include?(final_arg.node.type)
-                end
-              end
-              if argchain
-                if par.decl != :arg
-                  errors.concat kwarg_problems_for sig, argchain, api_map, block_pin, locals, location, pin, params, idx
-                  next
-                else
-                  if argchain.node.type == :splat && argchain == arguments.last
-                    final_arg = argchain
-                  end
-                  if (final_arg && final_arg.node.type == :splat)
-                    # The final argument given has been seen and was a
-                    # splat, which doesn't give us useful types or
-                    # arities against positional parameters, so let's
-                    # continue on in case there are any required
-                    # kwargs we should warn about
-                    next
-                  end
-
-                  if argchain.node.type == :splat && par != sig.parameters.last
-                    # we have been given a splat and there are more
-                    # arguments to come.
-
-                    # @todo Improve this so that we can skip past the
-                    #   rest of the positional parameters here but still
-                    #   process the kwargs
-                    break
-                  end
-                  ptype = params.key?(par.name) ? params[par.name][:qualified] : ComplexType::UNDEFINED
-                  ptype = ptype.self_to_type(par.context)
-                  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
+        end
+        if argchain
+          if par.decl != :arg
+            errors.concat kwarg_problems_for sig, argchain, api_map, closure_pin, locals, location, pin, params, idx
+            next
+          else
+            if argchain.node.type == :splat && argchain == arguments.last
+              final_arg = argchain
+            end
+            if (final_arg && final_arg.node.type == :splat)
+              # The final argument given has been seen and was a
+              # splat, which doesn't give us useful types or
+              # arities against positional parameters, so let's
+              # continue on in case there are any required
+              # kwargs we should warn about
+              next
             end
-            if errors.empty?
-              all_errors.clear
-              break
+            if argchain.node.type == :splat && par != sig.parameters.last
+              # we have been given a splat and there are more
+              # arguments to come.
+
+              # @todo Improve this so that we can skip past the
+              #   rest of the positional parameters here but still
+              #   process the kwargs
+              return errors
+            end
+            ptype = params.key?(par.name) ? params[par.name][:qualified] : ComplexType::UNDEFINED
+            ptype = ptype.self_to_type(par.context)
+            if ptype.nil?
+            # @todo Some level (strong, I guess) should require the param here
+            else
+              argtype = argchain.infer(api_map, closure_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}")
+                return errors
+              end
             end
-            all_errors.concat errors
           end
-          result.concat all_errors
+        elsif par.decl == :kwarg
+          errors.push Problem.new(location, "Call to #{pin.path} is missing keyword argument #{par.name}")
+          next
         end
-        base = base.base
       end
-      result
+      errors
     end
 
     # @param sig [Pin::Signature]
@@ -646,7 +664,6 @@ module Solargraph
     # @param parameters [Enumerable<Pin::Parameter>]
     # @todo need to use generic types in method to choose correct
     #   signature and generate Integer as return type
-    # @sg-ignore
     # @return [Integer]
     def required_param_count(parameters)
       parameters.sum { |param| %i[arg kwarg].include?(param.decl) ? 1 : 0 }
@@ -687,12 +704,48 @@ module Solargraph
       args
     end
 
+    # @return [Set<Integer>]
+    def sg_ignore_lines_processed
+      @sg_ignore_lines_processed ||= Set.new
+    end
+
+    # @return [Set<Integer>]
+    def all_sg_ignore_lines
+      source.associated_comments.select do |_line, text|
+        text.include?('@sg-ignore')
+      end.keys.to_set
+    end
+
+    # @return [Array<Integer>]
+    def unprocessed_sg_ignore_lines
+      (all_sg_ignore_lines - sg_ignore_lines_processed).to_a.sort
+    end
+
+    # @return [Array<Problem>]
+    def unneeded_sgignore_problems
+      return [] unless rules.validate_sg_ignores?
+
+      unprocessed_sg_ignore_lines.map do |line|
+        Problem.new(
+          Location.new(filename, Range.from_to(line, 0, line, 0)),
+          'Unneeded @sg-ignore comment'
+        )
+      end
+    end
+
     # @param problems [Array<Problem>]
     # @return [Array<Problem>]
     def without_ignored problems
       problems.reject do |problem|
-        node = source_map.source.node_at(problem.location.range.start.line, problem.location.range.start.column)
-        node && source_map.source.comments_for(node)&.include?('@sg-ignore')
+        node = source.node_at(problem.location.range.start.line, problem.location.range.start.column)
+        ignored = node && source.comments_for(node)&.include?('@sg-ignore')
+        unless !ignored || all_sg_ignore_lines.include?(problem.location.range.start.line)
+          # :nocov:
+          Solargraph.assert_or_log(:sg_ignore) { "@sg-ignore accounting issue - node is #{node}" }
+          # :nocov:
+        end
+        sg_ignore_lines_processed.add problem.location.range.start.line if ignored
+        ignored
       end
     end
   end

data/lib/solargraph/version.rb

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

data/lib/solargraph/workspace/config.rb

@@ -90,7 +90,6 @@ module Solargraph
 
       # A hash of options supported by the formatter
       #
-      # @sg-ignore pending https://github.com/castwide/solargraph/pull/905
       # @return [Hash]
       def formatter
         raw_data['formatter']
@@ -105,7 +104,6 @@ module Solargraph
 
       # The maximum number of files to parse from the workspace.
       #
-      # @sg-ignore pending https://github.com/castwide/solargraph/pull/905
       # @return [Integer]
       def max_files
         raw_data['max_files']
@@ -151,7 +149,7 @@ module Solargraph
       # @return [Hash{String => Array, Hash, Integer}]
       def default_config
         {
-          'include' => ['**/*.rb'],
+          'include' => ['Rakefile', 'Gemfile', '*.gemspec', '**/*.rb'],
           'exclude' => ['spec/**/*', 'test/**/*', 'vendor/**/*', '.bundle/**/*'],
           'require' => [],
           'domains' => [],

data/lib/solargraph/workspace/require_paths.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'open3'
+
+module Solargraph
+  # A workspace consists of the files in a project's directory and the
+  # project's configuration. It provides a Source for each file to be used
+  # in an associated Library or ApiMap.
+  #
+  class Workspace
+    # Manages determining which gemspecs are available in a workspace
+    class RequirePaths
+      attr_reader :directory, :config
+
+      # @param directory [String, nil]
+      # @param config [Config, nil]
+      def initialize directory, config
+        @directory = directory
+        @config = config
+      end
+
+      # Generate require paths from gemspecs if they exist or assume the default
+      # lib directory.
+      #
+      # @return [Array<String>]
+      def generate
+        result = require_paths_from_gemspec_files
+        return configured_require_paths if result.empty?
+        result.concat(config.require_paths.map { |p| File.join(directory, p) }) if config
+        result
+      end
+
+      private
+
+      # @return [Array<String>]
+      def require_paths_from_gemspec_files
+        results = []
+        gemspec_file_paths.each do |gemspec_file_path|
+          results.concat require_path_from_gemspec_file(gemspec_file_path)
+        end
+        results
+      end
+
+      # Get an array of all gemspec files in the workspace.
+      #
+      # @return [Array<String>]
+      def gemspec_file_paths
+        return [] if directory.nil?
+        @gemspec_file_paths ||= Dir[File.join(directory, '**/*.gemspec')].select do |gs|
+          config.nil? || config.allow?(gs)
+        end
+      end
+
+      # Get additional require paths defined in the configuration.
+      #
+      # @return [Array<String>]
+      def configured_require_paths
+        return ['lib'] unless directory
+        return [File.join(directory, 'lib')] if !config || config.require_paths.empty?
+        config.require_paths.map { |p| File.join(directory, p) }
+      end
+
+      # Generate require paths from gemspecs if they exist or assume the default
+      # lib directory.
+      #
+      # @param gemspec_file_path [String]
+      # @return [Array<String>]
+      def require_path_from_gemspec_file gemspec_file_path
+        base = File.dirname(gemspec_file_path)
+        # HACK: Evaluating gemspec files violates the goal of not running
+        #   workspace code, but this is how Gem::Specification.load does it
+        #   anyway.
+        cmd = ['ruby', '-e',
+               "require 'rubygems'; " \
+               "require 'json'; " \
+               "spec = eval(File.read('#{gemspec_file_path}'), TOPLEVEL_BINDING, '#{gemspec_file_path}'); " \
+               'return unless Gem::Specification === spec; ' \
+               'puts({name: spec.name, paths: spec.require_paths}.to_json)']
+        # @sg-ignore Unresolved call to capture3 on Module<Open3>
+        o, e, s = Open3.capture3(*cmd)
+        if s.success?
+          begin
+            hash = o && !o.empty? ? JSON.parse(o.split("\n").last) : {}
+            return [] if hash.empty?
+            hash['paths'].map { |path| File.join(base, path) }
+          rescue StandardError => e
+            Solargraph.logger.warn "Error reading #{gemspec_file_path}: [#{e.class}] #{e.message}"
+            []
+          end
+        else
+          Solargraph.logger.warn "Error reading #{gemspec_file_path}"
+          Solargraph.logger.warn e
+          []
+        end
+      end
+    end
+  end
+end