solargraph 0.40.0 → 0.41.0

data/lib/solargraph/parser/legacy/node_methods.rb

@@ -98,6 +98,7 @@ module Solargraph
 
         def convert_hash node
           return {} unless Parser.is_ast_node?(node) && node.type == :hash
+          return convert_hash(node.children[0].children[0]) if splatted_hash?(node)
           result = {}
           node.children.each do |pair|
             result[pair.children[0].children[0]] = Solargraph::Parser.chain(pair.children[1])
@@ -118,6 +119,14 @@ module Solargraph
           result
         end
 
+        def splatted_hash? node
+          Parser.is_ast_node?(node.children[0]) && node.children[0].type == :kwsplat
+        end
+
+        def splatted_call? node
+          Parser.is_ast_node?(node.children[0]) && node.children[0].type == :kwsplat && node.children[0].children[0].type != :hash
+        end
+
         # @todo Temporarily here for testing. Move to Solargraph::Parser.
         def call_nodes_from node
           return [] unless node.is_a?(::Parser::AST::Node)

data/lib/solargraph/parser/rubyvm/node_chainer.rb

@@ -109,7 +109,6 @@ module Solargraph
         end
 
         def node_to_argchains node
-          # @todo Process array, splat, argscat
           return [] unless Parser.is_ast_node?(node)
           if [:ZARRAY, :ARRAY, :LIST].include?(node.type)
             node.children[0..-2].map { |c| NodeChainer.chain(c) }

data/lib/solargraph/parser/rubyvm/node_methods.rb

@@ -90,7 +90,9 @@ module Solargraph
         end
 
         def convert_hash node
-          return {} unless node?(node) && node.type == :HASH && node?(node.children[0])
+          return {} unless node?(node) && node.type == :HASH
+          return convert_hash(node.children[0].children[1]) if splatted_hash?(node)
+          return {} unless node?(node.children[0])
           result = {}
           index = 0
           until index > node.children[0].children.length - 2
@@ -103,6 +105,21 @@ module Solargraph
           result
         end
 
+        def splatted_hash? node
+          splatted_node?(node) && node.children[0].children[1].type == :HASH
+        end
+
+        def splatted_node? node
+          node?(node.children[0]) &&
+            [:ARRAY, :LIST].include?(node.children[0].type) &&
+            node.children[0].children[0].nil? &&
+            node?(node.children[0].children[1])
+        end
+
+        def splatted_call? node
+          splatted_node?(node) && node.children[0].children[1].type != :HASH
+        end
+
         def node? node
           node.is_a?(RubyVM::AbstractSyntaxTree::Node)
         end

data/lib/solargraph/parser/rubyvm/node_processors/args_node.rb

@@ -32,7 +32,6 @@ module Solargraph
                   region.closure.parameters.push locals.last
                 end
               end
-              # @todo Optional args, keyword args, etc.
               if node.children[6]
                 locals.push Solargraph::Pin::Parameter.new(
                   location: region.closure.location,
@@ -55,19 +54,19 @@ module Solargraph
                 )
                 region.closure.parameters.push locals.last
               end
-              if node.children.last
-                locals.push Solargraph::Pin::Parameter.new(
-                  location: region.closure.location,
-                  closure: region.closure,
-                  comments: comments_for(node),
-                  name: node.children.last.to_s,
-                  presence: region.closure.location.range,
-                  decl: :blockarg
-                )
-                region.closure.parameters.push locals.last
-              end
             end
             process_children
+            if node.children.last
+              locals.push Solargraph::Pin::Parameter.new(
+                location: region.closure.location,
+                closure: region.closure,
+                comments: comments_for(node),
+                name: node.children.last.to_s,
+                presence: region.closure.location.range,
+                decl: :blockarg
+              )
+              region.closure.parameters.push locals.last
+            end
           end
 
           private

data/lib/solargraph/parser/rubyvm/node_processors/opt_arg_node.rb

@@ -16,12 +16,7 @@ module Solargraph
               presence: region.closure.location.range,
               decl: :optarg
             )
-            idx = region.closure.parameters.find_index { |par| par.decl != :arg }
-            if idx
-              region.closure.parameters.insert idx, locals.last
-            else
-              region.closure.parameters.push locals.last
-            end
+            region.closure.parameters.push locals.last
             node.children[1] && NodeProcessor.process(node.children[1], region, pins, locals)
           end
         end

data/lib/solargraph/parser/rubyvm/node_processors/send_node.rb

@@ -226,7 +226,7 @@ module Solargraph
 
           # @return [void]
           def process_private_constant
-            # @todo Bare `private_constant` causes an error
+            return unless Parser.is_ast_node?(node.children.last)
             node.children.last.children[0..-2].each do |child|
               if [:LIT, :STR].include?(child.type)
                 cn = child.children[0].to_s

data/lib/solargraph/source.rb

@@ -175,7 +175,7 @@ module Solargraph
       synced
     end
 
-    # @param position [Position]
+    # @param position [Position, Array(Integer, Integer)]
     # @return [Source::Cursor]
     def cursor_at position
       Cursor.new(self, position)

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

@@ -13,22 +13,6 @@ module Solargraph
           # return super_pins(api_map, name_pin) if word == 'super'
           []
         end
-
-        # @todo This is temporary. Chain heads need to handle arguments to
-        #   `super`.
-        # def arguments
-        #   []
-        # end
-
-        private
-
-        # # @param api_map [ApiMap]
-        # # @param name_pin [Pin::Base]
-        # # @return [Array<Pin::Base>]
-        # def super_pins api_map, name_pin
-        #   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
       end
     end
   end

data/lib/solargraph/source/source_chainer.rb

@@ -34,6 +34,7 @@ module Solargraph
         # Special handling for files that end with an integer and a period
         return Chain.new([Chain::Literal.new('Integer'), Chain::UNDEFINED_CALL]) if phrase =~ /^[0-9]+\.$/
         return Chain.new([Chain::Literal.new('Symbol')]) if phrase.start_with?(':') && !phrase.start_with?('::')
+        return SourceChainer.chain(source, Position.new(position.line, position.character + 1)) if end_of_phrase.strip == '::' && source.code[Position.to_offset(source.code, position)].to_s.match?(/[a-z]/i)
         begin
           return Chain.new([]) if phrase.end_with?('..')
           node = nil

data/lib/solargraph/source_map/mapper.rb

@@ -71,11 +71,6 @@ module Solargraph
           pos = Solargraph::Position.new(comment_position.line + line_num - 1, comment_position.column)
           process_directive(source_position, pos, d)
           last_line = line_num + 1
-          # @todo The below call assumes the topmost comment line. The above
-          #   process occasionally emits incorrect comment positions due to
-          #   blank lines in comment blocks, but at least it processes all the
-          #   directives.
-          # process_directive(source_position, comment_position, d)
         end
       end
 

data/lib/solargraph/type_checker.rb

@@ -95,7 +95,7 @@ module Solargraph
           result.push Problem.new(pin.location, "Untyped method #{pin.path} could not be inferred")
         end
       elsif rules.validate_tags?
-        unless pin.node.nil? || declared.void? || macro_pin?(pin) || abstract?(pin)
+        unless pin.node.nil? || declared.void? || virtual_pin?(pin) || abstract?(pin)
           inferred = pin.probe(api_map).self_to(pin.full_context.namespace)
           if inferred.undefined?
             unless rules.ignore_all_undefined? || external?(pin)
@@ -111,7 +111,7 @@ module Solargraph
       result
     end
 
-    def macro_pin? pin
+    def virtual_pin? pin
       pin.location && source_map.source.comment_at?(pin.location.range.ending)
     end
 
@@ -129,10 +129,10 @@ module Solargraph
           end
         end
       end
-      params.each_pair do |name, tag|
-        type = tag.qualify(api_map, pin.full_context.namespace)
+      params.each_pair do |name, data|
+        type = data[:qualified]
         if type.undefined?
-          result.push Problem.new(pin.location, "Unresolved type #{tag} for #{name} param on #{pin.path}", pin: pin)
+          result.push Problem.new(pin.location, "Unresolved type #{data[:tagged]} for #{name} param on #{pin.path}", pin: pin)
         end
       end
       result
@@ -266,12 +266,12 @@ module Solargraph
                 result.concat kwarg_problems_for argchain, api_map, block_pin, locals, location, pin, params, idx
                 break
               else
-                ptype = params[par.name]
+                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 && !any_types_match?(api_map, ptype, argtype)
+                  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}")
                   end
                 end
@@ -299,19 +299,19 @@ module Solargraph
           result.concat kwrestarg_problems_for(api_map, block_pin, locals, location, pin, params, kwargs)
         else
           if argchain
-            ptype = params[par.name]
-            if ptype.nil?
+            data = params[par.name]
+            if data.nil?
               # @todo Some level (strong, I guess) should require the param here
             else
+              ptype = data[:qualified]
+              next if ptype.undefined?
               argtype = argchain.infer(api_map, block_pin, locals)
               if argtype.defined? && ptype && !any_types_match?(api_map, ptype, argtype)
                 result.push Problem.new(location, "Wrong argument type for #{pin.path}: #{par.name} expected #{ptype}, received #{argtype}")
               end
             end
-          else
-            if par.decl == :kwarg
-              result.push Problem.new(location, "Call to #{pin.path} is missing keyword argument #{par.name}")
-            end
+          elsif par.decl == :kwarg
+            result.push Problem.new(location, "Call to #{pin.path} is missing keyword argument #{par.name}")
           end
         end
       end
@@ -321,31 +321,34 @@ module Solargraph
     def kwrestarg_problems_for(api_map, block_pin, locals, location, pin, params, kwargs)
       result = []
       kwargs.each_pair do |pname, argchain|
-        ptype = params[pname.to_s]
-        if ptype.nil?
-          # Probably nothing to do here. All of these args should be optional.
-        else
-          argtype = argchain.infer(api_map, block_pin, locals)
-          if argtype.defined? && ptype && !any_types_match?(api_map, ptype, argtype)
-            result.push Problem.new(location, "Wrong argument type for #{pin.path}: #{pname} expected #{ptype}, received #{argtype}")
-          end
+        next unless params.key?(pname.to_s)
+        ptype = params[pname.to_s][:qualified]
+        argtype = argchain.infer(api_map, block_pin, locals)
+        if argtype.defined? && ptype && !any_types_match?(api_map, ptype, argtype)
+          result.push Problem.new(location, "Wrong argument type for #{pin.path}: #{pname} expected #{ptype}, received #{argtype}")
         end
       end
       result
     end
 
+    # @param [Pin::Method]
+    # @return [Hash]
     def param_hash(pin)
       tags = pin.docstring.tags(:param)
       return {} if tags.empty?
       result = {}
       tags.each do |tag|
         next if tag.types.nil? || tag.types.empty?
-        result[tag.name.to_s] = Solargraph::ComplexType.try_parse(*tag.types).qualify(api_map, pin.full_context.namespace)
+        result[tag.name.to_s] = {
+          tagged: tag.types.join(', '),
+          qualified: Solargraph::ComplexType.try_parse(*tag.types).qualify(api_map, pin.full_context.namespace)
+        }
       end
       result
     end
 
     # @param [Array<Pin::Method>]
+    # @return [Hash]
     def first_param_hash(pins)
       pins.each do |pin|
         result = param_hash(pin)
@@ -413,24 +416,28 @@ module Solargraph
       end
       settled_kwargs = 0
       unless unchecked.empty?
-        kwargs = convert_hash(unchecked.last.node)
-        if pin.parameters.any? { |param| [:kwarg, :kwoptarg].include?(param.decl) || param.kwrestarg? }
-          if kwargs.empty?
-            add_params += 1
-          else
-            unchecked.pop
-            pin.parameters.each do |param|
-              next unless param.keyword?
-              if kwargs.key?(param.name.to_sym)
-                kwargs.delete param.name.to_sym
-                settled_kwargs += 1
-              elsif param.decl == :kwarg
-                return [Problem.new(location, "Missing keyword argument #{param.name} to #{pin.path}")]
+        if Parser.is_ast_node?(unchecked.last.node) && splatted_call?(unchecked.last.node)
+          settled_kwargs = pin.parameters.count(&:keyword?)
+        else
+          kwargs = convert_hash(unchecked.last.node)
+          if pin.parameters.any? { |param| [:kwarg, :kwoptarg].include?(param.decl) || param.kwrestarg? }
+            if kwargs.empty?
+              add_params += 1
+            else
+              unchecked.pop
+              pin.parameters.each do |param|
+                next unless param.keyword?
+                if kwargs.key?(param.name.to_sym)
+                  kwargs.delete param.name.to_sym
+                  settled_kwargs += 1
+                elsif param.decl == :kwarg
+                  return [Problem.new(location, "Missing keyword argument #{param.name} to #{pin.path}")]
+                end
+              end
+              kwargs.clear if pin.parameters.any?(&:kwrestarg?)
+              unless kwargs.empty?
+                return [Problem.new(location, "Unrecognized keyword argument #{kwargs.keys.first} to #{pin.path}")]
               end
-            end
-            kwargs.clear if pin.parameters.any?(&:kwrestarg?)
-            unless kwargs.empty?
-              return [Problem.new(location, "Unrecognized keyword argument #{kwargs.keys.first} to #{pin.path}")]
             end
           end
         end
@@ -443,6 +450,9 @@ module Solargraph
         if unchecked.length == req + opt + 1 && unchecked.last.links.last.is_a?(Source::Chain::BlockVariable)
           return []
         end
+        if req + add_params + 1 == unchecked.length && splatted_call?(unchecked.last.node) && (pin.parameters.map(&:decl) & [:kwarg, :kwoptarg, :kwrestarg]).any?
+          return []
+        end
         return [Problem.new(location, "Too many arguments to #{pin.path}")]
       elsif unchecked.length < req - settled_kwargs && (arguments.empty? || !arguments.last.splat?)
         return [Problem.new(location, "Not enough arguments to #{pin.path}")]

data/lib/solargraph/type_checker/checks.rb

@@ -1,5 +1,9 @@
+# frozen_string_literal: true
+
 module Solargraph
   class TypeChecker
+    # Helper methods for performing type checks
+    #
     module Checks
       module_function
 
@@ -62,7 +66,7 @@ module Solargraph
       # @param inferred [ComplexType]
       # @return [Boolean]
       def duck_types_match? api_map, expected, inferred
-        raise ArgumentError, "Expected type must be duck type" unless expected.duck_type?
+        raise ArgumentError, 'Expected type must be duck type' unless expected.duck_type?
         expected.each do |exp|
           next unless exp.duck_type?
           quack = exp.to_s[1..-1]
@@ -71,7 +75,7 @@ module Solargraph
         true
       end
 
-      # @param type [ComplexType]
+      # @param type [ComplexType::UniqueType]
       # @return [String]
       def fuzz type
         if type.parameters?
@@ -82,13 +86,13 @@ module Solargraph
       end
 
       # @param api_map [ApiMap]
-      # @param cls1 [ComplexType]
-      # @param cls2 [ComplexType]
+      # @param cls1 [ComplexType::UniqueType]
+      # @param cls2 [ComplexType::UniqueType]
       # @return [Boolean]
       def either_way?(api_map, cls1, cls2)
         f1 = fuzz(cls1)
         f2 = fuzz(cls2)
-        api_map.super_and_sub?(f1, f2) || api_map.super_and_sub?(f2, f1)
+        api_map.type_include?(f1, f2) || api_map.super_and_sub?(f1, f2) || api_map.super_and_sub?(f2, f1)
       end
     end
   end

data/lib/solargraph/type_checker/rules.rb

@@ -1,12 +1,16 @@
+# frozen_string_literal: true
+
 module Solargraph
   class TypeChecker
+    # Definitions of type checking rules to be performed at various levels
+    #
     class Rules
       LEVELS = {
         normal: 0,
         typed: 1,
         strict: 2,
         strong: 3
-      }
+      }.freeze
 
       # @return [Symbol]
       attr_reader :level

data/lib/solargraph/version.rb

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

data/lib/solargraph/workspace/config.rb

@@ -85,6 +85,13 @@ module Solargraph
         raw_data['reporters']
       end
 
+      # A hash of options supported by the formatter
+      #
+      # @return [Hash]
+      def formatter
+        raw_data['formatter']
+      end
+
       # An array of plugins to require.
       #
       # @return [Array<String>]
@@ -144,6 +151,14 @@ module Solargraph
           'require' => [],
           'domains' => [],
           'reporters' => %w[rubocop require_not_found],
+          'formatter' => {
+            'rubocop' => {
+              'cops' => 'safe',
+              'except' => [],
+              'only' => [],
+              'extra_args' =>[]
+            }
+          },
           'require_paths' => [],
           'plugins' => [],
           'max_files' => MAX_FILES
@@ -155,9 +170,10 @@ module Solargraph
       # @param globs [Array<String>]
       # @return [Array<String>]
       def process_globs globs
-        result = []
-        globs.each do |glob|
-          result.concat Dir[File.join directory, glob].map{ |f| f.gsub(/\\/, '/') }
+        result = globs.flat_map do |glob|
+          Dir[File.join directory, glob]
+            .map{ |f| f.gsub(/\\/, '/') }
+            .select { |f| File.file?(f) }
         end
         result
       end