solargraph 0.39.14 → 0.40.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 = []

data/lib/solargraph/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Solargraph
-  VERSION = '0.39.14'
+  VERSION = '0.40.1'
 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

data/lib/solargraph/yard_map/core_fills.rb

@@ -0,0 +1,185 @@
+module Solargraph
+  class YardMap
+    module CoreFills
+      Override = Pin::Reference::Override
+
+      KEYWORDS = [
+        '__ENCODING__', '__LINE__', '__FILE__', 'BEGIN', 'END', 'alias', 'and',
+        'begin', 'break', 'case', 'class', 'def', 'defined?', 'do', 'else',
+        'elsif', 'end', 'ensure', 'false', 'for', 'if', 'in', 'module', 'next',
+        'nil', 'not', 'or', 'redo', 'rescue', 'retry', 'return', 'self', 'super',
+        'then', 'true', 'undef', 'unless', 'until', 'when', 'while', 'yield'
+      ].map { |k| Pin::Keyword.new(k) }
+
+      methods_with_yieldparam_subtypes = %w[
+        Array#each Array#map Array#map! Array#any? Array#all? Array#index
+        Array#keep_if Array#delete_if
+        Enumerable#each_entry Enumerable#map Enumerable#any? Enumerable#all?
+        Enumerable#select Enumerable#reject
+        Set#each
+      ]
+
+      OVERRIDES = [
+        Override.method_return('Array#concat', 'Array'),
+        Override.method_return('Array#keep_if', 'self'),
+        Override.method_return('Array#delete_if', 'self'),
+        Override.from_comment('Array#map', %(
+@overload map(&block)
+  @return [Array]
+@overload map()
+  @return [Enumerator]
+        )),
+        Override.from_comment('Array#reject', %(
+@overload reject(&block)
+  @return [self]
+@overload reject()
+  @return [Enumerator]
+        )),
+        Override.method_return('Array#reverse', 'self', delete: ['overload']),
+        Override.from_comment('Array#select', %(
+@overload select(&block)
+  @return [self]
+@overload select()
+  @return [Enumerator]
+        )),
+        Override.from_comment('Array#[]', %(
+@overload [](range)
+  @param range [Range]
+  @return [self]
+@overload [](num1, num2)
+  @param num1 [Integer]
+  @param num2 [Integer]
+  @return [self]
+@overload [](num)
+  @param num [Integer]
+  @return_single_parameter
+@return_single_parameter
+        )),
+        Override.from_comment('Array#first', %(
+@overload first(num)
+  @param num [Integer]
+  @return [self]
+@return_single_parameter
+        )),
+        Override.from_comment('Array#last', %(
+@overload last(num)
+  @param num [Integer]
+  @return [self]
+@return_single_parameter
+        )),
+        Override.method_return('Array#map', 'Array'),
+        Override.method_return('Array#uniq', 'self'),
+        Override.method_return('Array#zip', 'Array, nil'),
+
+        Override.from_comment('BasicObject#==', %(
+@param other [BasicObject]
+@return [Boolean]
+        )),
+        Override.method_return('BasicObject#initialize', 'void'),
+
+        Override.method_return('Class#new', 'self'),
+        Override.method_return('Class.new', 'Class<Object>'),
+        Override.method_return('Class#allocate', 'self'),
+        Override.method_return('Class.allocate', 'Class<Object>'),
+
+        Override.method_return('Enumerable#select', 'self'),
+
+        Override.method_return('File.absolute_path', 'String'),
+        Override.method_return('File.basename', 'String'),
+        Override.method_return('File.dirname', 'String'),
+        Override.method_return('File.extname', 'String'),
+        Override.method_return('File.join', 'String'),
+
+        Override.from_comment('Float#+', %(
+@param y [Numeric]
+@return [Numeric]
+        )),
+
+        Override.from_comment('Hash#[]', %(
+@return_value_parameter
+        )),
+
+        # @todo This override isn't robust enough. It needs to allow for
+        #   parameterized Hash types, e.g., [Hash{Symbol => String}].
+        Override.from_comment('Hash#[]=', %(
+@param_tuple
+        )),
+
+        Override.method_return('Hash#merge', 'Hash'),
+
+        Override.from_comment('Integer#+', %(
+@param y [Numeric]
+@return [Numeric]
+        )),
+
+        Override.method_return('Kernel#puts', 'nil'),
+
+        Override.from_comment('Numeric#+', %(
+@param y [Numeric]
+@return [Numeric]
+        )),
+
+        Override.method_return('Object#!', 'Boolean'),
+        Override.method_return('Object#clone', 'self', delete: [:overload]),
+        Override.method_return('Object#dup', 'self', delete: [:overload]),
+        Override.method_return('Object#freeze', 'self', delete: [:overload]),
+        Override.method_return('Object#inspect', 'String'),
+        Override.method_return('Object#taint', 'self'),
+        Override.method_return('Object#to_s', 'String'),
+        Override.method_return('Object#untaint', 'self'),
+        Override.from_comment('Object#tap', %(
+@return [self]
+@yieldparam [self]
+        )),
+
+        Override.from_comment('STDERR', %(
+@type [IO]
+        )),
+
+        Override.from_comment('STDIN', %(
+@type [IO]
+        )),
+
+        Override.from_comment('STDOUT', %(
+@type [IO]
+        )),
+
+        Override.method_return('String#freeze', 'self'),
+        Override.method_return('String#split', 'Array<String>'),
+        Override.method_return('String#lines', 'Array<String>'),
+        Override.from_comment('String#each_line', %(
+@yieldparam [String]
+        )),
+        Override.from_comment('String.new', %(
+@overload new(*)
+  @return [self]
+      ))
+      ].concat(
+        methods_with_yieldparam_subtypes.map do |path|
+          Override.from_comment(path, %(
+@yieldparam_single_parameter
+            ))
+        end
+      )
+
+      PINS = [
+        Pin::Reference::Superclass.new(closure: Pin::Namespace.new(name: 'File'), name: 'IO'),
+        Pin::Reference::Superclass.new(closure: Pin::Namespace.new(name: 'Integer'), name: 'Numeric'),
+        Pin::Reference::Superclass.new(closure: Pin::Namespace.new(name: 'Float'), name: 'Numeric')
+      ].concat(
+        # HACK: Add Errno exception classes
+        begin
+          errno = Solargraph::Pin::Namespace.new(name: 'Errno')
+          result = []
+          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
+          result
+        end
+      )
+
+      ALL = KEYWORDS + PINS + OVERRIDES
+    end
+  end
+end

data/lib/solargraph/yard_map/helpers.rb

@@ -0,0 +1,16 @@
+module Solargraph
+  class YardMap
+    module Helpers
+      module_function
+
+      # @param code_object [YARD::CodeObjects::Base]
+      # @param spec [Gem::Specification]
+      # @return [Solargraph::Location, nil]
+      def object_location code_object, spec
+        return nil if spec.nil? || code_object.nil? || code_object.file.nil? || code_object.line.nil?
+        file = File.join(spec.full_gem_path, code_object.file)
+        Solargraph::Location.new(file, Solargraph::Range.from_to(code_object.line - 1, 0, code_object.line - 1, 0))
+      end
+    end
+  end
+end

data/lib/solargraph/yard_map/mapper.rb

@@ -3,6 +3,10 @@
 module Solargraph
   class YardMap
     class Mapper
+      autoload :ToMethod, 'solargraph/yard_map/mapper/to_method'
+      autoload :ToNamespace, 'solargraph/yard_map/mapper/to_namespace'
+      autoload :ToConstant, 'solargraph/yard_map/mapper/to_constant'
+
       # @param code_objects [Array<YARD::CodeObjects::Base>]
       # @param spec [Gem::Specification]
       def initialize code_objects, spec = nil
@@ -23,22 +27,24 @@ module Solargraph
         @pins
       end
 
+      private
+
       # @param code_object [YARD::CodeObjects::Base]
       # @return [Array<Pin::Base>]
       def generate_pins code_object
         result = []
         if code_object.is_a?(YARD::CodeObjects::NamespaceObject)
-          nspin = Solargraph::Pin::YardPin::Namespace.new(code_object, @spec, @namespace_pins[code_object.namespace.to_s])
+          nspin = ToNamespace.make(code_object, @spec, @namespace_pins[code_object.namespace.to_s])
           @namespace_pins[code_object.path] = nspin
           result.push nspin
           if code_object.is_a?(YARD::CodeObjects::ClassObject) and !code_object.superclass.nil?
             # This method of superclass detection is a bit of a hack. If
             # the superclass is a Proxy, it is assumed to be undefined in its
             # yardoc and converted to a fully qualified namespace.
-            if code_object.superclass.is_a?(YARD::CodeObjects::Proxy)
-              superclass = "::#{code_object.superclass}"
+            superclass = if code_object.superclass.is_a?(YARD::CodeObjects::Proxy)
+              "::#{code_object.superclass}"
             else
-              superclass = code_object.superclass.to_s
+              code_object.superclass.to_s
             end
             result.push Solargraph::Pin::Reference::Superclass.new(name: superclass, closure: nspin)
           end
@@ -55,14 +61,14 @@ module Solargraph
           closure = @namespace_pins[code_object.namespace.to_s]
           if code_object.name == :initialize && code_object.scope == :instance
             # @todo Check the visibility of <Class>.new
-            result.push Solargraph::Pin::YardPin::Method.new(code_object, 'new', :class, :public, closure, @spec)
-            result.push Solargraph::Pin::YardPin::Method.new(code_object, 'initialize', :instance, :private, closure, @spec)
+            result.push ToMethod.make(code_object, 'new', :class, :public, closure, @spec)
+            result.push ToMethod.make(code_object, 'initialize', :instance, :private, closure, @spec)
           else
-            result.push Solargraph::Pin::YardPin::Method.new(code_object, nil, nil, nil, closure, @spec)
+            result.push ToMethod.make(code_object, nil, nil, nil, closure, @spec)
           end
         elsif code_object.is_a?(YARD::CodeObjects::ConstantObject)
           closure = @namespace_pins[code_object.namespace]
-          result.push Solargraph::Pin::YardPin::Constant.new(code_object, closure, @spec)
+          result.push ToConstant.make(code_object, closure, @spec)
         end
         result
       end