solargraph 0.39.16 → 0.40.3

data/lib/solargraph/pin/method_alias.rb

@@ -6,7 +6,7 @@ module Solargraph
     # examples that defer mapping are aliases for superclass methods or
     # methods from included modules.
     #
-    class MethodAlias < BaseMethod
+    class MethodAlias < Method
       # @return [::Symbol]
       attr_reader :scope
 

data/lib/solargraph/position.rb

@@ -40,20 +40,8 @@ module Solargraph
     # @param position [Position]
     # @return [Integer]
     def self.to_offset text, position
-      result = 0
-      feed = 0
-      line = position.line
-      column = position.character
-      text.lines.each do |l|
-        line_length = l.length
-        if feed == line
-          result += column
-          break
-        end
-        result += line_length
-        feed += 1
-      end
-      result
+      return 0 if text.empty?
+      text.lines[0...position.line].sum(&:length) + position.character
     end
 
     # Get a numeric offset for the specified text and a position identified

data/lib/solargraph/source.rb

@@ -284,7 +284,7 @@ module Solargraph
 
     FOLDING_NODE_TYPES = if Parser.rubyvm?
       %i[
-        CLASS SCLASS MODULE DEFN DEFS IF WHILE UNLESS ITER STR
+        CLASS SCLASS MODULE DEFN DEFS IF WHILE UNLESS ITER STR HASH ARRAY LIST
       ].freeze
     else
       %i[
@@ -345,18 +345,22 @@ module Solargraph
 
     # @param top [Parser::AST::Node]
     # @param result [Array<Range>]
+    # @param parent [Symbol]
     # @return [void]
-    def inner_folding_ranges top, result = []
+    def inner_folding_ranges top, result = [], parent = nil
       # return unless top.is_a?(::Parser::AST::Node)
       return unless Parser.is_ast_node?(top)
       if FOLDING_NODE_TYPES.include?(top.type)
-        range = Range.from_node(top)
-        if result.empty? || range.start.line > result.last.start.line
-          result.push range unless range.ending.line - range.start.line < 2
+        # @todo Smelly exception for hash's first-level array in RubyVM
+        unless [:ARRAY, :LIST].include?(top.type) && parent == :HASH
+          range = Range.from_node(top)
+          if result.empty? || range.start.line > result.last.start.line
+            result.push range unless range.ending.line - range.start.line < 2
+          end
         end
       end
       top.children.each do |child|
-        inner_folding_ranges(child, result)
+        inner_folding_ranges(child, result, top.type)
       end
     end
 

data/lib/solargraph/source/chain.rb

@@ -119,12 +119,12 @@ module Solargraph
           @@inference_stack.pop
           if type.defined?
             possibles.push type
-            break if pin.is_a?(Pin::BaseMethod)
+            break if pin.is_a?(Pin::Method)
           end
         end
         if possibles.empty?
           # Limit method inference recursion
-          return ComplexType::UNDEFINED if @@inference_depth >= 10 && pins.first.is_a?(Pin::BaseMethod)
+          return ComplexType::UNDEFINED if @@inference_depth >= 10 && pins.first.is_a?(Pin::Method)
           @@inference_depth += 1
           pins.each do |pin|
             # Avoid infinite recursion
@@ -134,7 +134,7 @@ module Solargraph
             @@inference_stack.pop
             if type.defined?
               possibles.push type
-              break if pin.is_a?(Pin::BaseMethod)
+              break if pin.is_a?(Pin::Method)
             end
           end
           @@inference_depth -= 1

data/lib/solargraph/source_map.rb

@@ -30,7 +30,7 @@ module Solargraph
       @source = source.dup
       @pins = pins
       @locals = locals
-      environ.merge Convention.for(source)
+      environ.merge Convention.for_local(self) unless filename.nil?
       @pin_class_hash = pins.to_set.classify(&:class).transform_values(&:to_a)
       @pin_select_cache = {}
     end
@@ -168,6 +168,9 @@ module Solargraph
       position = Position.new(line, character)
       found = nil
       pins.each do |pin|
+        # @todo Attribute pins should not be treated like closures, but
+        #   there's probably a better way to handle it
+        next if pin.is_a?(Pin::Method) && pin.attribute?
         found = pin if (klasses.empty? || klasses.any? { |kls| pin.is_a?(kls) } ) && pin.location.range.contain?(position)
         break if pin.location.range.start.line > line
       end

data/lib/solargraph/source_map/clip.rb

@@ -149,7 +149,7 @@ module Solargraph
         frag_start = cursor.start_of_word.to_s.downcase
         filtered = result.uniq(&:name).select { |s|
           s.name.downcase.start_with?(frag_start) &&
-            (!s.is_a?(Pin::BaseMethod) || s.name.match(/^[a-z0-9_]+(\!|\?|=)?$/i))
+            (!s.is_a?(Pin::Method) || s.name.match(/^[a-z0-9_]+(\!|\?|=)?$/i))
         }
         Completion.new(filtered, cursor.range)
       end
@@ -212,7 +212,8 @@ module Solargraph
             result.concat api_map.get_constants(context_pin.context.namespace, *gates)
             result.concat api_map.get_methods(block.binder.namespace, scope: block.binder.scope, visibility: [:public, :private, :protected])
             result.concat api_map.get_methods('Kernel')
-            result.concat ApiMap.keywords
+            # result.concat ApiMap.keywords
+            result.concat api_map.keyword_pins
             result.concat yielded_self_pins
           end
         end

data/lib/solargraph/source_map/mapper.rb

@@ -126,27 +126,31 @@ module Solargraph
           namespace = closure_at(source_position)
           t = (directive.tag.types.nil? || directive.tag.types.empty?) ? nil : directive.tag.types.flatten.join('')
           if t.nil? || t.include?('r')
-            pins.push Solargraph::Pin::Attribute.new(
+            pins.push Solargraph::Pin::Method.new(
               location: location,
               closure: namespace,
               name: directive.tag.name,
               comments: docstring.all.to_s,
-              access: :reader,
               scope: namespace.is_a?(Pin::Singleton) ? :class : :instance,
               visibility: :public,
-              explicit: false
+              explicit: false,
+              attribute: true
             )
           end
           if t.nil? || t.include?('w')
-            pins.push Solargraph::Pin::Attribute.new(
+            pins.push Solargraph::Pin::Method.new(
               location: location,
               closure: namespace,
               name: "#{directive.tag.name}=",
               comments: docstring.all.to_s,
-              access: :writer,
               scope: namespace.is_a?(Pin::Singleton) ? :class : :instance,
-              visibility: :public
+              visibility: :public,
+              attribute: true
             )
+            pins.last.parameters.push Pin::Parameter.new(name: 'value', decl: :arg, closure: pins.last)
+            if pins.last.return_type.defined?
+              pins.last.docstring.add_tag YARD::Tags::Tag.new(:param, '', pins.last.return_type.to_s.split(', '), 'value')
+            end
           end
         when 'parse'
           begin

data/lib/solargraph/type_checker.rb

@@ -73,15 +73,15 @@ module Solargraph
     # @return [Array<Problem>]
     def method_tag_problems
       result = []
-      # @param pin [Pin::BaseMethod]
-      source_map.pins_by_class(Pin::BaseMethod).each do |pin|
+      # @param pin [Pin::Method]
+      source_map.pins_by_class(Pin::Method).each do |pin|
         result.concat method_return_type_problems_for(pin)
         result.concat method_param_type_problems_for(pin)
       end
       result
     end
 
-    # @param pin [Pin::BaseMethod]
+    # @param pin [Pin::Method]
     # @return [Array<Problem>]
     def method_return_type_problems_for pin
       result = []
@@ -115,7 +115,7 @@ module Solargraph
       pin.location && source_map.source.comment_at?(pin.location.range.ending)
     end
 
-    # @param pin [Pin::BaseMethod]
+    # @param pin [Pin::Method]
     # @return [Array<Problem>]
     def method_param_type_problems_for pin
       stack = api_map.get_method_stack(pin.namespace, pin.name, scope: pin.scope)
@@ -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
@@ -147,14 +147,12 @@ module Solargraph
       result = []
       all_variables.each do |pin|
         if pin.return_type.defined?
-          # @todo Somwhere in here we still need to determine if the variable is defined by an external call
           declared = pin.typify(api_map)
           if declared.defined?
             if rules.validate_tags?
               inferred = pin.probe(api_map)
               if inferred.undefined?
                 next if rules.ignore_all_undefined?
-                # next unless internal?(pin) # @todo This might be redundant for variables
                 if declared_externally?(pin)
                   ignored_pins.push pin
                 else
@@ -172,7 +170,6 @@ module Solargraph
             result.push Problem.new(pin.location, "Unresolved type #{pin.return_type} for variable #{pin.name}", pin: pin)
           end
         else
-          # @todo Check if the variable is defined by an external call
           inferred = pin.probe(api_map)
           if inferred.undefined? && declared_externally?(pin)
             ignored_pins.push pin
@@ -227,7 +224,7 @@ module Solargraph
             base = base.base
           end
           closest = found.typify(api_map) if found
-          if !found || closest.defined? || internal?(found)
+          if !found || (closest.defined? && internal_or_core?(found))
             unless ignored_pins.include?(found)
               result.push Problem.new(location, "Unresolved call to #{missing.links.last.word}")
               @marked_ranges.push rng
@@ -244,8 +241,8 @@ module Solargraph
       base = chain
       until base.links.length == 1 && base.undefined?
         pins = base.define(api_map, block_pin, locals)
-        if pins.first.is_a?(Pin::BaseMethod)
-          # @type [Pin::BaseMethod]
+        if pins.first.is_a?(Pin::Method)
+          # @type [Pin::Method]
           pin = pins.first
           ap = if base.links.last.is_a?(Solargraph::Source::Chain::ZSuper)
             arity_problems_for(pin, fake_args_for(block_pin), location)
@@ -269,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
@@ -302,20 +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
-              # @todo Problem: missing required keyword argument
-              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
@@ -325,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)
@@ -360,9 +359,14 @@ module Solargraph
 
     # @param pin [Pin::Base]
     def internal? pin
+      return false if pin.nil?
       pin.location && api_map.bundled?(pin.location.filename)
     end
 
+    def internal_or_core? pin
+      internal?(pin) || api_map.yard_map.core_pins.include?(pin) || api_map.yard_map.stdlib_pins.include?(pin)
+    end
+
     # @param pin [Pin::Base]
     def external? pin
       !internal? pin
@@ -395,7 +399,7 @@ module Solargraph
       true
     end
 
-    # @param pin [Pin::BaseMethod]
+    # @param pin [Pin::Method]
     def arity_problems_for(pin, arguments, location)
       return [] unless pin.explicit?
       return [] if pin.parameters.empty? && arguments.empty?
@@ -410,9 +414,12 @@ module Solargraph
       if unchecked.empty? && pin.parameters.any? { |param| param.decl == :kwarg }
         return [Problem.new(location, "Missing keyword arguments to #{pin.path}")]
       end
+      settled_kwargs = 0
       unless unchecked.empty?
-        kwargs = convert_hash(unchecked.last.node)
-        # unless kwargs.empty?
+        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
@@ -422,6 +429,7 @@ module Solargraph
                 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
@@ -432,7 +440,7 @@ module Solargraph
               end
             end
           end
-        # end
+        end
       end
       req = required_param_count(pin)
       if req + add_params < unchecked.length
@@ -442,24 +450,22 @@ 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 && (arguments.empty? || !arguments.last.splat?)
+      elsif unchecked.length < req - settled_kwargs && (arguments.empty? || !arguments.last.splat?)
         return [Problem.new(location, "Not enough arguments to #{pin.path}")]
       end
       []
     end
 
-    # @param pin [Pin::BaseMethod]
+    # @param pin [Pin::Method]
     def required_param_count(pin)
-      count = 0
-      pin.parameters.each do |param|
-        break unless param.decl == :arg
-        count += 1
-      end
-      count
+      pin.parameters.sum { |param| %i[arg kwarg].include?(param.decl) ? 1 : 0 }
     end
 
-    # @param pin [Pin::BaseMethod]
+    # @param pin [Pin::Method]
     def optional_param_count(pin)
       count = 0
       pin.parameters.each do |param|

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]

data/lib/solargraph/type_checker/param_def.rb

@@ -20,7 +20,7 @@ module Solargraph
       class << self
         # Get an array of ParamDefs from a method pin.
         #
-        # @param pin [Solargraph::Pin::BaseMethod]
+        # @param pin [Solargraph::Pin::Method]
         # @return [Array<ParamDef>]
         def from pin
           result = []