solargraph 0.39.15 → 0.40.2

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

@@ -110,18 +110,21 @@ module Solargraph
       # @param api_map [ApiMap]
       # @return [ComplexType]
       def infer_first_defined pins, context, api_map
-        type = ComplexType::UNDEFINED
+        possibles = []
         pins.each do |pin|
           # Avoid infinite recursion
           next if @@inference_stack.include?(pin.identity)
           @@inference_stack.push pin.identity
           type = pin.typify(api_map)
           @@inference_stack.pop
-          break if type.defined?
+          if type.defined?
+            possibles.push type
+            break if pin.is_a?(Pin::Method)
+          end
         end
-        if type.undefined?
+        if possibles.empty?
           # Limit method inference recursion
-          return type 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
@@ -129,10 +132,20 @@ module Solargraph
             @@inference_stack.push pin.identity
             type = pin.probe(api_map)
             @@inference_stack.pop
-            break if type.defined?
+            if type.defined?
+              possibles.push type
+              break if pin.is_a?(Pin::Method)
+            end
           end
           @@inference_depth -= 1
         end
+        return ComplexType::UNDEFINED if possibles.empty?
+        type = if possibles.length > 1
+          sorted = possibles.map { |t| t.rooted? ? "::#{t}" : t.to_s }.sort { |a, _| a == 'nil' ? 1 : 0 }
+          ComplexType.parse(*sorted)
+        else
+          possibles.first
+        end
         return type if context.nil? || context.return_type.undefined?
         type.self_to(context.return_type.namespace)
       end

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)
@@ -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)
@@ -313,7 +310,6 @@ module Solargraph
             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
           end
@@ -338,6 +334,8 @@ module Solargraph
       result
     end
 
+    # @param [Pin::Method]
+    # @return [Hash]
     def param_hash(pin)
       tags = pin.docstring.tags(:param)
       return {} if tags.empty?
@@ -350,6 +348,7 @@ module Solargraph
     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
@@ -443,23 +451,18 @@ module Solargraph
           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/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 = []

data/lib/solargraph/version.rb

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

data/lib/solargraph/yard_map.rb

@@ -10,11 +10,15 @@ module Solargraph
   # stdlib, and gems.
   #
   class YardMap
-    autoload :Cache,    'solargraph/yard_map/cache'
-    autoload :CoreDocs, 'solargraph/yard_map/core_docs'
-    autoload :CoreGen,  'solargraph/yard_map/core_gen'
-    autoload :Mapper,   'solargraph/yard_map/mapper'
-    autoload :RdocToYard, 'solargraph/yard_map/rdoc_to_yard'
+    autoload :Cache,       'solargraph/yard_map/cache'
+    autoload :CoreDocs,    'solargraph/yard_map/core_docs'
+    autoload :CoreGen,     'solargraph/yard_map/core_gen'
+    autoload :Mapper,      'solargraph/yard_map/mapper'
+    autoload :RdocToYard,  'solargraph/yard_map/rdoc_to_yard'
+    autoload :CoreFills,   'solargraph/yard_map/core_fills'
+    autoload :StdlibFills, 'solargraph/yard_map/stdlib_fills'
+    autoload :Helpers,     'solargraph/yard_map/helpers'
+    autoload :ToMethod,    'solargraph/yard_map/to_method'
 
     CoreDocs.require_minimum
 
@@ -50,6 +54,8 @@ module Solargraph
     def initialize(required: [], gemset: {}, with_dependencies: true)
       # HACK: YardMap needs its own copy of this array
       @required = required.clone
+      # HACK: Hardcoded YAML handling
+      @required.push 'psych' if @required.include?('yaml')
       @with_dependencies = with_dependencies
       @gem_paths = {}
       @stdlib_namespaces = []
@@ -74,6 +80,8 @@ module Solargraph
     # @param new_gemset [Hash{String => String}]
     # @return [Boolean]
     def change new_requires, new_gemset, source_gems = []
+      # HACK: Hardcoded YAML handling
+      new_requires.push 'psych' if new_requires.include?('yaml')
       if new_requires.uniq.sort == required.uniq.sort && new_gemset == gemset && @source_gems.uniq.sort == source_gems.uniq.sort
         false
       else
@@ -131,7 +139,7 @@ module Solargraph
     # @param path [String]
     # @return [Pin::Base]
     def path_pin path
-      pins.select{ |p| p.path == path }.first
+      pins.select { |p| p.path == path }.first
     end
 
     # Get the location of a file referenced by a require path.
@@ -151,6 +159,10 @@ module Solargraph
       nil
     end
 
+    def stdlib_pins
+      @stdlib_pins ||= []
+    end
+
     private
 
     # @return [YardMap::Cache]
@@ -158,10 +170,12 @@ module Solargraph
       @cache ||= YardMap::Cache.new
     end
 
+    # @return [Hash]
     def pin_class_hash
       @pin_class_hash ||= pins.to_set.classify(&:class).transform_values(&:to_a)
     end
 
+    # @return [Array<Pin::Base>]
     def pins_by_class klass
       @pin_select_cache[klass] ||= pin_class_hash.select { |key, _| key <= klass }.values.flatten
     end
@@ -179,12 +193,13 @@ module Solargraph
 
     # @return [void]
     def process_requires
-      pins.clear
+      pins.replace core_pins
       unresolved_requires.clear
-      # stdnames = {}
+      stdlib_pins.clear
+      environ = Convention.for_global(self)
       done = []
       from_std = []
-      required.each do |r|
+      (required + environ.requires).each do |r|
         next if r.nil? || r.empty? || done.include?(r)
         done.push r
         cached = cache.get_path_pins(r)
@@ -209,7 +224,6 @@ module Solargraph
             yardocs.unshift yd
             result.concat process_yardoc yd, spec
             result.concat add_gem_dependencies(spec) if with_dependencies?
-            stdlib_fill r, result
           end
         rescue Gem::LoadError => e
           base = r.split('/').first
@@ -219,7 +233,7 @@ module Solargraph
           if stdtmp.empty?
             unresolved_requires.push r
           else
-            stdlib_fill base, stdtmp
+            stdlib_pins.concat stdtmp
             result.concat stdtmp
           end
         end
@@ -229,7 +243,13 @@ module Solargraph
           pins.concat result
         end
       end
-      pins.concat core_pins
+      if required.include?('yaml') && required.include?('psych')
+        # HACK: Hardcoded YAML handling
+        # @todo Why can't this be handled with an override or a virtual pin?
+        pin = path_pin('YAML')
+        pin.instance_variable_set(:@return_type, ComplexType.parse('Module<Psych>')) unless pin.nil?
+      end
+      pins.concat environ.pins
     end
 
     # @param spec [Gem::Specification]
@@ -327,22 +347,6 @@ module Solargraph
       spec
     end
 
-    # @param path [String]
-    # @param pins [Array<Pin::Base>]
-    # @return [void]
-    def stdlib_fill path, pins
-      StdlibFills.get(path).each do |ovr|
-        pin = pins.select { |p| p.path == ovr.name }.first
-        next if pin.nil?
-        (ovr.tags.map(&:tag_name) + ovr.delete).uniq.each do |tag|
-          pin.docstring.delete_tags tag.to_sym
-        end
-        ovr.tags.each do |tag|
-          pin.docstring.add_tag(tag)
-        end
-      end
-    end
-
     def load_core_pins
       yd = CoreDocs.yardoc_file
       ser = File.join(File.dirname(yd), 'core.ser')
@@ -360,23 +364,7 @@ module Solargraph
       else
         read_core_and_save_cache(yd, ser)
       end
-      # HACK: Add Errno exception classes
-      errno = result.select{ |pin| pin.path == 'Errno' }.first
-      Errno.constants.each do |const|
-        result.push Solargraph::Pin::Namespace.new(type: :class, name: const.to_s, closure: errno)
-        result.push Solargraph::Pin::Reference::Superclass.new(closure: result.last, name: 'SystemCallError')
-      end
-      CoreFills::OVERRIDES.each do |ovr|
-        pin = result.select { |p| p.path == ovr.name }.first
-        next if pin.nil?
-        (ovr.tags.map(&:tag_name) + ovr.delete).uniq.each do |tag|
-          pin.docstring.delete_tags tag.to_sym
-        end
-        ovr.tags.each do |tag|
-          pin.docstring.add_tag(tag)
-        end
-      end
-      result
+      ApiMap::Store.new(result + CoreFills::ALL).pins.reject { |pin| pin.is_a?(Pin::Reference::Override) }
     end
 
     def read_core_and_save_cache yd, ser
@@ -384,7 +372,7 @@ module Solargraph
       load_yardoc yd
       result.concat Mapper.new(YARD::Registry.all).map
       # HACK: Assume core methods with a single `args` parameter accept restarg
-      result.select { |pin| pin.is_a?(Solargraph::Pin::BaseMethod )}.each do |pin|
+      result.select { |pin| pin.is_a?(Solargraph::Pin::Method )}.each do |pin|
         if pin.parameters.length == 1 && pin.parameters.first.name == 'args' && pin.parameters.first.decl == :arg
           # @todo Smelly instance variable access
           pin.parameters.first.instance_variable_set(:@decl, :restarg)
@@ -403,7 +391,7 @@ module Solargraph
 
     def load_stdlib_pins base
       ser = File.join(File.dirname(CoreDocs.yardoc_stdlib_file), "#{base}.ser")
-      if File.file?(ser)
+      result = if File.file?(ser)
         Solargraph.logger.info "Loading #{base} stdlib from cache"
         file = File.open(ser, 'rb')
         dump = file.read
@@ -418,6 +406,11 @@ module Solargraph
       else
         read_stdlib_and_save_cache(base, ser)
       end
+      fills = StdlibFills.get(base)
+      unless fills.empty?
+        result = ApiMap::Store.new(result + fills).pins.reject { |pin| pin.is_a?(Pin::Reference::Override) }
+      end
+      result
     end
 
     def read_stdlib_and_save_cache base, ser