solargraph 0.32.5 → 0.33.0

data/lib/solargraph/api_map/store.rb

@@ -6,7 +6,7 @@ module Solargraph
       # @return [Array<Solargraph::Pin::Base>]
       attr_reader :pins
 
-      # @param pins [Array<Solargraph::Source>]
+      # @param pins [Array<Solargraph::Pin::Base>]
       def initialize pins = []
         @pins = pins
         index
@@ -26,16 +26,16 @@ module Solargraph
       # @param visibility [Array<Symbol>]
       # @return [Array<Solargraph::Pin::Base>]
       def get_methods fqns, scope: :instance, visibility: [:public]
-        kinds = [Pin::METHOD, Pin::ATTRIBUTE]
-        namespace_children(fqns).select{ |pin|
+        kinds = [Pin::METHOD, Pin::ATTRIBUTE, Pin::METHOD_ALIAS]
+        namespace_children(fqns).select do |pin|
           kinds.include?(pin.kind) && pin.scope == scope && visibility.include?(pin.visibility)
-        }
+        end
       end
 
       # @param fqns [String]
       # @return [String]
       def get_superclass fqns
-        return superclass_references[fqns].first if superclass_references.has_key?(fqns)
+        return superclass_references[fqns].first if superclass_references.key?(fqns)
         nil
       end
 
@@ -54,15 +54,17 @@ module Solargraph
       # @param path [String]
       # @return [Array<Solargraph::Pin::Base>]
       def get_path_pins path
-        return [] if path.nil? # @todo Should be '' instead?
-        pins.select { |pin| pin.path == path }
+        path_pin_hash[path] || []
       end
 
       # @param fqns [String]
       # @param scope [Symbol] :class or :instance
       # @return [Array<Solargraph::Pin::Base>]
       def get_instance_variables(fqns, scope = :instance)
-        namespace_children(fqns).select{|pin| pin.kind == Pin::INSTANCE_VARIABLE and pin.context.scope == scope}
+        # namespace_children(fqns).select{|pin| pin.kind == Pin::INSTANCE_VARIABLE and pin.context.scope == scope}
+        all_instance_variables.select { |pin|
+          pin.binder.namespace == fqns && pin.binder.scope == scope
+        }
       end
 
       # @param fqns [String]
@@ -89,12 +91,14 @@ module Solargraph
 
       # @return [Array<Solargraph::Pin::Base>]
       def namespace_pins
-        @namespace_pins ||= pins.select{|p| p.kind == Pin::NAMESPACE}
+        # @namespace_pins ||= pins.select{|p| p.kind == Pin::NAMESPACE}
+        @namespace_pins ||= []
       end
 
       # @return [Array<Solargraph::Pin::Base>]
       def method_pins
-        @method_pins ||= pins.select{|p| p.kind == Pin::METHOD or p.kind == Pin::ATTRIBUTE}
+        # @method_pins ||= pins.select{|p| p.kind == Pin::METHOD or p.kind == Pin::ATTRIBUTE}
+        @method_pins ||= []
       end
 
       # @param fqns [String]
@@ -121,6 +125,11 @@ module Solargraph
         end
       end
 
+      # @return [Array<Pin::Block>]
+      def block_pins
+        @block_pins ||= []
+      end
+
       def inspect
         # Avoid insane dumps in specs
         to_s
@@ -171,16 +180,32 @@ module Solargraph
         @namespace_map ||= {}
       end
 
+      def all_instance_variables
+        @all_instance_variables ||= []
+      end
+
+      def path_pin_hash
+        @path_pin_hash ||= {}
+      end
+
       # @return [void]
       def index
         namespace_map.clear
         namespaces.clear
+        namespace_pins.clear
+        method_pins.clear
         symbols.clear
+        block_pins.clear
+        all_instance_variables.clear
+        path_pin_hash.clear
         namespace_map[''] = []
+        override_pins = []
         pins.each do |pin|
           namespace_map[pin.namespace] ||= []
           namespace_map[pin.namespace].push pin
           namespaces.add pin.path if pin.kind == Pin::NAMESPACE and !pin.path.empty?
+          namespace_pins.push pin if pin.kind == Pin::NAMESPACE
+          method_pins.push pin if pin.kind == Pin::METHOD || pin.kind == Pin::ATTRIBUTE
           symbols.push pin if pin.kind == Pin::SYMBOL
           if pin.kind == Pin::INCLUDE_REFERENCE
             include_references[pin.namespace] ||= []
@@ -191,10 +216,28 @@ module Solargraph
           elsif pin.kind == Pin::SUPERCLASS_REFERENCE
             superclass_references[pin.namespace] ||= []
             superclass_references[pin.namespace].push pin.name
+          elsif pin.is_a?(Pin::Block)
+            block_pins.push pin
+          elsif pin.is_a?(Pin::InstanceVariable)
+            all_instance_variables.push pin
+          elsif pin.is_a?(Pin::Reference::Override)
+            override_pins.push pin
+          end
+          if pin.path
+            path_pin_hash[pin.path] ||= []
+            path_pin_hash[pin.path].push pin
+          end
+        end
+        override_pins.concat CoreFills::OVERRIDES
+        override_pins.each do |ovr|
+          pin = get_path_pins(ovr.name).first
+          next if pin.nil?
+          pin.docstring.delete_tags(:overload)
+          pin.docstring.delete_tags(:return)
+          ovr.tags.each do |tag|
+            pin.docstring.add_tag(tag)
           end
         end
-        @namespace_pins = nil
-        @method_pins = nil
       end
     end
   end

data/lib/solargraph/complex_type.rb

@@ -1,35 +1,57 @@
 module Solargraph
   # A container for type data based on YARD type tags.
   #
-  class ComplexType < Array
-    # @todo Figure out how to add the basic type methods here without actually
-    #   including the module. One possibility:
-    #
+  class ComplexType
     # @!parse
     #   include TypeMethods
 
     autoload :TypeMethods, 'solargraph/complex_type/type_methods'
     autoload :UniqueType,  'solargraph/complex_type/unique_type'
 
-    # @param types [Array<ComplexType>]
-    def initialize types = [ComplexType::UNDEFINED]
-      super()
-      concat types
+    # @param types [Array<UniqueType>]
+    def initialize types = [UniqueType::UNDEFINED]
+      @items = types
     end
 
     # @param api_map [ApiMap]
     # @param context [String]
     # @return [ComplexType]
     def qualify api_map, context = ''
-      types = map do |t|
+      types = @items.map do |t|
         t.qualify api_map, context
       end
       ComplexType.new(types)
     end
 
+    def first
+      @items.first
+    end
+
+    def map &block
+      @items.map &block
+    end
+
+    # @yieldparam [UniqueType]
+    # @return [Array]
+    def each &block
+      @items.each &block
+    end
+
+    def length
+      @items.length
+    end
+
+    def [](index)
+      @items[index]
+    end
+
+    def select &block
+      @items.select &block
+    end
+
     def method_missing name, *args, &block
-      return if first.nil?
-      return first.send(name, *args, &block) if respond_to_missing?(name)
+      return if @items.first.nil?
+      return @items.first.send(name, *args, &block) if respond_to_missing?(name)
       super
     end
 
@@ -41,6 +63,20 @@ module Solargraph
       map(&:tag).join(', ')
     end
 
+    def all? &block
+      @items.all? &block
+    end
+
+    def selfy?
+      @items.any?(&:selfy?)
+    end
+
+    def self_to dst
+      return self unless selfy?
+      result = @items.map { |i| i.self_to dst }
+      ComplexType.parse(*result.map(&:tag))
+    end
+
     class << self
       # Parse type strings into a ComplexType.
       #
@@ -81,7 +117,8 @@ module Solargraph
                 subtype_string += char
               elsif base.end_with?('=')
                 raise ComplexTypeError, "Invalid hash thing" unless key_types.nil?
-                types.push ComplexType.new([UniqueType.new(base[0..-2].strip)])
+                # types.push ComplexType.new([UniqueType.new(base[0..-2].strip)])
+                types.push UniqueType.new(base[0..-2].strip)
                 key_types = types
                 types = []
                 base = ''
@@ -108,7 +145,8 @@ module Solargraph
               raise ComplexTypeError, "Invalid close in type #{type_string}" if paren_stack < 0
               next
             elsif char == ',' && point_stack == 0 && curly_stack == 0 && paren_stack == 0
-              types.push ComplexType.new([UniqueType.new(base.strip, subtype_string.strip)])
+              # types.push ComplexType.new([UniqueType.new(base.strip, subtype_string.strip)])
+              types.push UniqueType.new(base.strip, subtype_string.strip)
               base = ''
               subtype_string = ''
               next
@@ -122,7 +160,8 @@ module Solargraph
           base.strip!
           subtype_string.strip!
           raise ComplexTypeError, "Unclosed subtype in #{type_string}" if point_stack != 0 || curly_stack != 0 || paren_stack != 0
-          types.push ComplexType.new([UniqueType.new(base, subtype_string)])
+          # types.push ComplexType.new([UniqueType.new(base, subtype_string)])
+          types.push UniqueType.new(base, subtype_string)
         end
         unless key_types.nil?
           raise ComplexTypeError, "Invalid use of key/value parameters" unless partial
@@ -134,6 +173,8 @@ module Solargraph
         result
       end
 
+      # @param strings [Array<String>]
+      # @return [ComplexType]
       def try_parse *strings
         parse *strings
       rescue ComplexTypeError => e
@@ -146,5 +187,8 @@ module Solargraph
     UNDEFINED = ComplexType.parse('undefined')
     SYMBOL = ComplexType.parse('Symbol')
     ROOT = ComplexType.parse('Class<>')
+    NIL = ComplexType.parse('nil')
+    SELF = ComplexType.parse('self')
+    BOOLEAN = ComplexType.parse('Boolean')
   end
 end

data/lib/solargraph/complex_type/type_methods.rb

@@ -99,8 +99,8 @@ module Solargraph
         recon = (rooted? ? '' : context)
         fqns = api_map.qualify(name, recon)
         if fqns.nil?
-          return ComplexType.parse('Boolean') if tag == 'Boolean'
-          return ComplexType::UNDEFINED
+          return UniqueType::BOOLEAN if tag == 'Boolean'
+          return UniqueType::UNDEFINED
         end
         fqns = "::#{fqns}" # Ensure the resulting complex type is rooted
         ltypes = key_types.map do |t|

data/lib/solargraph/complex_type/unique_type.rb

@@ -26,11 +26,15 @@ module Solargraph
         @key_types = []
         @subtypes = []
         return unless parameters?
-        subs = ComplexType.parse(substring[1..-2], partial: true)
+        if @substring.start_with?('<(') && @substring.end_with?(')>')
+          subs = ComplexType.parse(substring[2..-3], partial: true)
+        else
+          subs = ComplexType.parse(substring[1..-2], partial: true)
+        end
         if hash_parameters?
-          raise ComplexTypeError, "Bad hash type" unless !subs.is_a?(ComplexType) and subs.length == 2 and !subs[0].is_a?(ComplexType) and !subs[1].is_a?(ComplexType)
-          @key_types.concat subs[0]
-          @subtypes.concat subs[1]
+          raise ComplexTypeError, "Bad hash type" unless !subs.is_a?(ComplexType) and subs.length == 2 and !subs[0].is_a?(UniqueType) and !subs[1].is_a?(UniqueType)
+          @key_types.concat subs[0].map { |u| ComplexType.new([u]) }
+          @subtypes.concat subs[1].map { |u| ComplexType.new([u]) }
         else
           @subtypes.concat subs
         end
@@ -39,6 +43,31 @@ module Solargraph
       def to_s
         tag
       end
+
+      def self_to dst
+        return self unless selfy?
+        new_name = (@name == 'self' ? dst : @name)
+        new_key_types = @key_types.map { |t| t.self_to dst }
+        new_subtypes = @subtypes.map { |t| t.self_to dst }
+        if hash_parameters?
+          UniqueType.new(new_name, "{#{new_key_types.join(', ')} => #{new_subtypes.join(', ')}}")
+        elsif parameters?
+          if @substring.start_with?'<('
+            UniqueType.new(new_name, "<(#{new_subtypes.join(', ')})>")
+          else
+            UniqueType.new(new_name, "<#{new_subtypes.join(', ')}>")
+          end
+        else
+          UniqueType.new(new_name)
+        end
+      end
+
+      def selfy?
+        @name == 'self' || @key_types.any?(&:selfy?) || @subtypes.any?(&:selfy?)
+      end
+
+      UNDEFINED = UniqueType.new('undefined')
+      BOOLEAN = UniqueType.new('Boolean')
     end
   end
 end

data/lib/solargraph/core_fills.rb

@@ -8,30 +8,58 @@ module Solargraph
       'then', 'true', 'undef', 'unless', 'until', 'when', 'while', 'yield'
     ].freeze
 
-    METHODS_RETURNING_SELF = %w[
-      Array#select Array#reject Array#keep_if Array#delete_if
-      Enumerable#select
-      Object#clone Object#dup Object#freeze Object#taint Object#untaint Object#tap
-      String#freeze
-    ].freeze
-
     METHODS_RETURNING_SUBTYPES = %w[
       Array#[] Array#first Array#last
     ].freeze
 
+    METHODS_RETURNING_VALUE_TYPES = %w[
+      Hash#[]
+    ].freeze
+
     METHODS_WITH_YIELDPARAM_SELF = %w[
       Object#tap
     ].freeze
 
     METHODS_WITH_YIELDPARAM_SUBTYPES = %w[
-      Array#each Array#map Array#any? Array#all? Array#index
+      Array#each 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
     ].freeze
 
-    CUSTOM_RETURN_TYPES = {
-      'String#split' => 'Array<String>',
-      'String#lines' => 'Array<String>'
-    }.freeze
+    class << self
+      private
+
+      def override path, *tags
+        Solargraph::Pin::Reference::Override.new(nil, path, [YARD::Tags::Tag.new('return', nil, tags)])
+      end
+    end
+
+    OVERRIDES = [
+      override('Array#select', 'self'),
+      override('Array#reject', 'self'),
+      override('Array#keep_if', 'self'),
+      override('Array#delete_if', 'self'),
+
+      override('Class#new', 'self'),
+      override('Class.new', 'Class<Object>'),
+      override('Class#allocate', 'self'),
+      override('Class.allocate', 'Class<Object>'),
+
+      override('Enumerable#select', 'self'),
+
+      override('Object#!', 'Boolean'),
+      override('Object#clone', 'self'),
+      override('Object#dup', 'self'),
+      override('Object#freeze', 'self'),
+      override('Object#taint', 'self'),
+      override('Object#untaint', 'self'),
+      override('Object#tap', 'self'),
+
+      override('String#freeze', 'self'),
+      override('String#split', 'Array<String>'),
+      override('String#lines', 'Array<String>')
+    ]
   end
 end

data/lib/solargraph/diagnostics.rb

@@ -8,8 +8,8 @@ module Solargraph
     autoload :Rubocop,         'solargraph/diagnostics/rubocop'
     autoload :RubocopHelpers,  'solargraph/diagnostics/rubocop_helpers'
     autoload :RequireNotFound, 'solargraph/diagnostics/require_not_found'
-    autoload :TypeNotDefined,  'solargraph/diagnostics/type_not_defined'
     autoload :UpdateErrors,    'solargraph/diagnostics/update_errors'
+    autoload :TypeCheck,       'solargraph/diagnostics/type_check'
 
     class << self
       # Add a reporter with a name to identify it in .solargraph.yml files.
@@ -25,7 +25,7 @@ module Solargraph
       #
       # @return [Array<String>]
       def reporters
-        reporter_hash.keys
+        reporter_hash.keys - ['type_not_defined'] # @todo Hide type_not_defined for now
       end
 
       # Find a reporter by name.
@@ -46,7 +46,8 @@ module Solargraph
 
     register 'rubocop', Rubocop
     register 'require_not_found', RequireNotFound
-    register 'type_not_defined', TypeNotDefined
+    register 'typecheck', TypeCheck
     register 'update_errors', UpdateErrors
+    register 'type_not_defined', TypeCheck # @todo Retained for backwards compatibility
   end
 end

data/lib/solargraph/diagnostics/base.rb

@@ -3,6 +3,12 @@ module Solargraph
     # The base class for diagnostics reporters.
     #
     class Base
+      attr_reader :args
+
+      def initialize *args
+        @args = args
+      end
+
       # Perform a diagnosis on a Source within the context of an ApiMap.
       # The result is an array of hash objects that conform to the LSP's
       # Diagnostic specification.