solargraph 0.24.1 → 0.25.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c068cbe7c4d090f33124e8a8ab52a9f956992aab3c5db9e5f41ba41f65642be3
-  data.tar.gz: 1798f2d5c48fa1d794c7441102154d464ce4cb8a75ea77d759c9eea27dbfc492
+  metadata.gz: efdf4fdf971f5d10e148b73902701dae0ce549ef38f7304455fefba0465f4e90
+  data.tar.gz: 49c3fcc4fb9c3ad339e7e08c256275ac73907edc62f239a4b315938c18b68661
 SHA512:
-  metadata.gz: 1aac2a042e292cf73c3bb70559b9a67d7a0d1c75537f669b20cfffd1bb1a41a820c67f9c4a845e23bce24cc5f1384a3dad7055a91b138f910ff4099633834f3f
-  data.tar.gz: f204e7cbee66ffa0e5a5d0a0086e8415e222a13a576b6a394ca840cf5a7f9401fe9570953db9770274262b1524b820f17c020c711b65c9dac1cc44b157d464dc
+  metadata.gz: d3bddec5d8f6f083905349634b6a36144b5e069b1b94abf0d2ab3e3f074e8bc851ceb79a6d42cee9b2aa9af4645f3ed04347228a16db08fc3b94b7ff974aa0e3
+  data.tar.gz: 6b384c71d2a38c4e5cd02cabb2801d0b57cf5c5f2eb81d63cb56e37fb90b24c030d308cd2e75dc3977963841d1dfcb1f1e33eb8f220a759b83580296c40fb413

data/lib/solargraph/api_map.rb

@@ -23,9 +23,6 @@ module Solargraph
     # @return [Solargraph::Workspace]
     attr_reader :workspace
 
-    # @return [ApiMap::Store]
-    attr_reader :store
-
     # Get a LiveMap associated with the current workspace.
     #
     # @return [Solargraph::LiveMap]
@@ -36,14 +33,13 @@ module Solargraph
       @workspace = workspace
       require_extensions
       @virtual_source = nil
-      @yard_stale = true
-      # process_maps
       @sources = workspace.sources
       refresh_store_and_maps
     end
 
     # Create an ApiMap with a workspace in the specified directory.
     #
+    # @param directory [String]
     # @return [ApiMap]
     def self.load directory
       self.new(Solargraph::Workspace.new(directory))
@@ -71,17 +67,6 @@ module Solargraph
       result.uniq
     end
 
-    # Get a YardMap associated with the current workspace.
-    #
-    # @return [Solargraph::YardMap]
-    def yard_map
-      # refresh
-      if @yard_map.required.to_set != required.to_set
-        @yard_map = Solargraph::YardMap.new(required: required, workspace: workspace)
-      end
-      @yard_map
-    end
-
     # Declare a virtual source that will be included in the map regardless of
     # whether it's in the workspace.
     #
@@ -91,6 +76,8 @@ module Solargraph
     # @param source [Solargraph::Source]
     # @return [Solargraph::Source]
     def virtualize source
+      # @todo Confirm the correct way to handle caches
+      cache.clear if (source.nil? and !@virtual_source.nil?) or (!source.nil? and !@virtual_source.nil? and source.pins != @virtual_source.pins)
       store.remove @virtual_source unless @virtual_source.nil?
       domains.clear
       domains.concat workspace.config.domains
@@ -133,12 +120,8 @@ module Solargraph
       if force
         refresh_store_and_maps
       else
-        store.remove *(current_workspace_sources.reject{ |s| workspace.sources.include?(s) })
-        @sources = workspace.sources
-        @sources.push @virtual_source unless @virtual_source.nil?
-        store.update *(@sources.select{ |s| @stime.nil? or s.stime > @stime })
+        update_store_and_maps
       end
-      @stime = Time.new
       true
     end
 
@@ -187,6 +170,8 @@ module Solargraph
     # @return [Array<Solargraph::Pin::Base>]
     def get_constants namespace, context = ''
       namespace ||= ''
+      cached = cache.get_constants(namespace, context)
+      return cached.clone unless cached.nil?
       skip = []
       result = []
       bases = context.split('::')
@@ -202,6 +187,7 @@ module Solargraph
       visibility = [:public]
       visibility.push :private if fqns == context
       result.concat inner_get_constants(fqns, visibility, skip)
+      cache.set_constants(namespace, context, result)
       result
     end
 
@@ -212,10 +198,19 @@ module Solargraph
     # @param context [String] The context to search
     # @return [String]
     def qualify namespace, context = ''
-      inner_qualify namespace, context, []
+      # @todo The return for self might work better elsewhere
+      return qualify(context) if namespace == 'self'
+      cached = cache.get_qualified_namespace(namespace, context)
+      return cached.clone unless cached.nil?
+      result = inner_qualify(namespace, context, [])
+      cache.set_qualified_namespace(namespace, context, result)
+      result
     end
 
     # @deprecated Use #qualify instead
+    # @param namespace [String]
+    # @param context [String]
+    # @return [String]
     def find_fully_qualified_namespace namespace, context = ''
       qualify namespace, context
     end
@@ -260,6 +255,8 @@ module Solargraph
     # @param deep [Boolean] True to include superclasses, mixins, etc.
     # @return [Array<Solargraph::Pin::Base>]
     def get_methods fqns, scope: :instance, visibility: [:public], deep: true
+      cached = cache.get_methods(fqns, scope, visibility, deep)
+      return cached.clone unless cached.nil?
       result = []
       skip = []
       if fqns == ''
@@ -278,6 +275,23 @@ module Solargraph
         exist = result.map(&:name)
         result.concat live.reject{|p| exist.include?(p.name)}
       end
+      cache.set_methods(fqns, scope, visibility, deep, result)
+      result
+    end
+
+    # Get a stack of method pins for a method name in a namespace. The order
+    # of the pins corresponds to the ancestry chain, with highest precedence
+    # first.
+    #
+    # @param fqns [String]
+    # @param name [String]
+    # @param scope [Symbol] :instance or :class
+    # @return [Array<Solargraph::Pin::Base>]
+    def get_method_stack fqns, name, scope: :instance
+      # cached = cache.get_method_stack(fqns, name, scope)
+      # return cached.clone unless cached.nil?
+      result = get_methods(fqns, scope: scope, visibility: [:private, :protected, :public]).select{|p| p.name == name}
+      # cache.set_method_stack(fqns, name, scope, result)
       result
     end
 
@@ -328,7 +342,10 @@ module Solargraph
           pins = probe.infer_signature_pins(fragment.base, fragment.named_path, fragment.locals)
           unless pins.empty?
             pin = pins.first
-            if pin.return_complex_types.any? and pin.return_complex_types.first.duck_type?
+            if pin.variable? and pin.return_type.nil? and !pin.signature.nil?
+              type = probe.infer_signature_type(pin.signature, pin.context, fragment.locals)
+              result.concat(get_methods(type)) unless type.nil?
+            elsif pin.return_complex_types.any? and pin.return_complex_types.first.duck_type?
               pin.return_complex_types.each do |t|
                 next unless t.duck_type?
                 result.push Pin::DuckMethod.new(pin.location, t.tag[1..-1])
@@ -350,7 +367,7 @@ module Solargraph
         end
       end
       frag_start = fragment.word.to_s.downcase
-      filtered = result.uniq(&:identifier).select{|s| s.name.downcase.start_with?(frag_start) and (s.kind != Pin::METHOD or s.name.match(/^[a-z0-9_]*(\!|\?|=)?$/i))}.sort_by.with_index{ |x, idx| [x.name, idx] }
+      filtered = result.uniq(&:identifier).select{|s| s.name.downcase.start_with?(frag_start) and (s.kind != Pin::METHOD or s.name.match(/^[a-z0-9_]+(\!|\?|=)?$/i))}.sort_by.with_index{ |x, idx| [x.name, idx] }
       Completion.new(filtered, fragment.whole_word_range)
     end
 
@@ -360,7 +377,7 @@ module Solargraph
     # @return [Array<Solargraph::Pin::Base>]
     def define fragment
       return get_path_suggestions(fragment.namespace) if fragment.whole_signature == 'self'
-      return [] if fragment.string? or fragment.comment? or fragment.literal? or fragment.whole_signature == 'self'
+      return [] if fragment.string? or fragment.comment? or fragment.literal? or KEYWORDS.include?(fragment.whole_signature)
       if fragment.base_literal?
         probe.infer_signature_pins fragment.whole_signature, Pin::ProxyMethod.new(fragment.base_literal), fragment.locals
       else
@@ -406,7 +423,7 @@ module Solargraph
       return [] if path.nil?
       result = []
       result.concat store.get_path_pins(path)
-      result.concat yard_map.objects(path)
+      # result.concat yard_map.objects(path)
       if result.empty?
         lp = live_map.get_path_pin(path)
         result.push lp unless lp.nil?
@@ -430,7 +447,7 @@ module Solargraph
           found.push k if k.downcase.include?(query.downcase)
         end
       end
-      found.concat(yard_map.search(query)).uniq.sort
+      found
     end
 
     # Get YARD documentation for the specified path.
@@ -445,7 +462,7 @@ module Solargraph
       @yard_stale = false
       docs = []
       docs.push code_object_at(path) unless code_object_at(path).nil?
-      docs.concat yard_map.document(path)
+      # docs.concat yard_map.document(path)
       docs
     end
 
@@ -461,6 +478,7 @@ module Solargraph
       result
     end
 
+    # @param location [Solargraph::Source::Location]
     # @return [Solargraph::Pin::Base]
     def locate_pin location
       @sources.each do |source|
@@ -477,27 +495,53 @@ module Solargraph
       @probe ||= Probe.new(self)
     end
 
+    def unresolved_requires
+      # return [] if yard_map_changed?
+      yard_map.unresolved_requires
+    end
+
     private
 
+    # @return [ApiMap::Store]
+    def store
+      @store ||= ApiMap::Store.new(@sources, yard_map.pins)
+    end
+
+    # @return [void]
     def refresh_store_and_maps
-      @store = ApiMap::Store.new(@sources)
+      @yard_stale = true
       @live_map = Solargraph::LiveMap.new(self)
-      @yard_map = Solargraph::YardMap.new(required: required, workspace: workspace)
+      store.update_yard(yard_map.pins) if yard_map.change(required)
+      cache.clear
+      @stime = Time.now
     end
 
+    # @return [void]
+    def update_store_and_maps
+      @yard_stale = true
+      store.remove *(current_workspace_sources.reject{ |s| workspace.sources.include?(s) })
+      @sources = workspace.sources
+      @sources.push @virtual_source unless @virtual_source.nil?
+      store.update *(@sources.select{ |s| @stime.nil? or s.stime > @stime })
+      store.update_yard(yard_map.pins) if yard_map.change(required)
+      cache.clear
+      @stime = Time.now
+    end
+
+    # @return [void]
     def process_virtual
-      unless @virtual_source.nil?
-        map_source @virtual_source
+      map_source @virtual_source unless @virtual_source.nil?
+      if yard_map.change(required)
+        store.update_yard(yard_map.pins)
       end
+      cache.clear
     end
 
-    # @param [Solargraph::Source]
+    # @param source [Solargraph::Source]
+    # @return [void]
     def map_source source
       store.update source
       path_macros.merge! source.path_macros
-      source.required.each do |r|
-        required.push r
-      end
     end
 
     # @return [Solargraph::ApiMap::Cache]
@@ -525,17 +569,17 @@ module Solargraph
             fqim = qualify(im, fqns)
             result.concat inner_get_methods(fqim, scope, visibility, deep, skip) unless fqim.nil?
           end
-          result.concat yard_map.get_instance_methods(fqns, visibility: visibility)
+          # result.concat yard_map.get_instance_methods(fqns, visibility: visibility)
           result.concat inner_get_methods('Object', :instance, [:public], deep, skip) unless fqns == 'Object'
         else
           store.get_extends(fqns).each do |em|
             fqem = qualify(em, fqns)
             result.concat inner_get_methods(fqem, :instance, visibility, deep, skip) unless fqem.nil?
           end
-          result.concat yard_map.get_methods(fqns, '', visibility: visibility)
+          # result.concat yard_map.get_methods(fqns, '', visibility: visibility)
           type = get_namespace_type(fqns)
           result.concat inner_get_methods('Class', :instance, fqns == '' ? [:public] : visibility, deep, skip) if type == :class
-          result.concat inner_get_methods('Module', :instance, fqns == '' ? [:public] : visibility, deep, skip) if type == :module
+          result.concat inner_get_methods('Module', :instance, fqns == '' ? [:public] : visibility, deep, skip) #if type == :module
         end
       end
       result
@@ -546,7 +590,7 @@ module Solargraph
       skip.push fqns
       result = []
       result.concat store.get_constants(fqns, visibility)
-      result.concat yard_map.get_constants(fqns)
+      # result.concat yard_map.get_constants(fqns)
       store.get_includes(fqns).each do |is|
         fqis = qualify(is, fqns)
         result.concat inner_get_constants(fqis, [:public], skip) unless fqis.nil?
@@ -613,11 +657,7 @@ module Solargraph
           return name if store.namespace_exists?(name)
         end
       end
-      result = yard_map.find_fully_qualified_namespace(name, root)
-      if result.nil?
-        result = live_map.get_fqns(name, root)
-      end
-      result
+      live_map.get_fqns(name, root)
     end
 
     # Get the namespace's type (Class or Module).
@@ -626,8 +666,15 @@ module Solargraph
     # @return [Symbol] :class, :module, or nil
     def get_namespace_type fqns
       pin = store.get_path_pins(fqns).first
-      return yard_map.get_namespace_type(fqns) if pin.nil?
+      return nil if pin.nil?
       pin.type
     end
+
+    # Get a YardMap associated with the current workspace.
+    #
+    # @return [Solargraph::YardMap]
+    def yard_map
+      @yard_map ||= Solargraph::YardMap.new(required: required, workspace: workspace)
+    end
   end
 end

data/lib/solargraph/api_map/cache.rb

@@ -4,6 +4,10 @@ module Solargraph
       def initialize
         @signature_types = {}
         @assignment_node_types = {}
+        @methods = {}
+        @method_stacks = {}
+        @constants = {}
+        @qualified_namespaces = {}
       end
 
       def get_signature_type signature, namespace, scope
@@ -26,9 +30,56 @@ module Solargraph
         @assignment_node_types[[node, namespace]] = value
       end
 
+      def get_methods fqns, scope, visibility, deep
+        @methods[[fqns, scope, visibility.sort, deep]]
+      end
+
+      def set_methods fqns, scope, visibility, deep, value
+        @methods[[fqns, scope, visibility.sort, deep]] = value
+      end
+
+      def get_method_stack fqns, name, scope
+        @method_stacks[[fqns, name, scope]]
+      end
+
+      def set_method_stack fqns, name, scope, value
+        @method_stacks[[fqns, name, scope]] = value
+      end
+
+      def get_constants namespace, context
+        @constants[[namespace, context]]
+      end
+
+      def set_constants namespace, context, value
+        @constants[[namespace, context]] = value
+      end
+
+      def get_qualified_namespace name, context
+        @qualified_namespaces[[name, context]]
+      end
+
+      def set_qualified_namespace name, context, value
+        @qualified_namespaces[[name, context]] = value
+      end
+
+      # @return [void]
       def clear
         @signature_types.clear
         @assignment_node_types.clear
+        @methods.clear
+        @method_stacks.clear
+        @constants.clear
+        @qualified_namespaces.clear
+      end
+
+      # @return [Boolean]
+      def empty?
+        @signature_types.empty? and
+          @assignment_node_types.empty? and
+          @methods.empty? and
+          @method_stacks.empty? and
+          @constants.empty? amd
+          @qualified_namespaces.empty?
       end
     end
   end

data/lib/solargraph/api_map/probe.rb

@@ -1,17 +1,23 @@
 module Solargraph
   class ApiMap
+    # A deep analysis provider for ApiMaps.
+    #
     class Probe
       include TypeMethods
 
       # @return [Solargraph::ApiMap]
       attr_reader :api_map
 
+      # @param api_map [ApiMap]
       def initialize api_map
         @api_map = api_map
       end
 
       # Get all matching pins for the signature.
       #
+      # @param signature [String]
+      # @param context_pin [Pin::Base]
+      # @param locals [Array<Pin::Base>]
       # @return [Array<Pin::Base>]
       def infer_signature_pins signature, context_pin, locals
         return [] if signature.nil? or signature.empty?
@@ -44,6 +50,9 @@ module Solargraph
 
       # Get the return type for the signature.
       #
+      # @param signature [String]
+      # @param context_pin [Pin::Base]
+      # @param locals [Array<Pin::Base>]
       # @return [String]
       def infer_signature_type signature, context_pin, locals
         pins = infer_signature_pins(signature, context_pin, locals)
@@ -65,6 +74,8 @@ module Solargraph
         return resolve_word_types(lvars, locals) unless lvars.empty?
         return api_map.get_global_variable_pins.select{|pin| pin.name == word} if word.start_with?('$')
         namespace, scope = extract_namespace_and_scope_from_pin(context_pin)
+        return api_map.get_class_variable_pins(namespace).select{|pin| pin.name == word} if word.start_with?('@@')
+        return api_map.get_instance_variable_pins(namespace, scope).select{|pin| pin.name == word} if word.start_with?('@')
         return api_map.pins.select{|pin| word_matches_context?(word, namespace, scope, pin)} if variable_name?(word)
         result = []
         cparts = namespace.split('::')
@@ -75,7 +86,8 @@ module Solargraph
           cparts.pop
         end
         result.concat api_map.get_path_suggestions(word) if result.empty?
-        result.concat api_map.get_methods(namespace, scope: scope, visibility: [:public, :private, :protected]).select{|pin| pin.name == word} unless word.include?('::')
+        # result.concat api_map.get_methods(namespace, scope: scope, visibility: [:public, :private, :protected]).select{|pin| pin.name == word} unless word.include?('::')
+        result.concat api_map.get_method_stack(namespace, word, scope: scope) unless word.include?('::')
         result.concat api_map.get_constants('', namespace).select{|pin| pin.name == word} if result.empty?
         resolve_word_types(result, locals)
       end
@@ -85,8 +97,9 @@ module Solargraph
           next unless p.return_type.nil?
           type = resolve_pin_type(p, locals)
           # @todo Smelly instance variable access
-          p.instance_variable_set(:@return_type, type)
+          p.instance_variable_set(:@return_complex_types, ComplexType.parse(type)) unless type.nil?
         end
+        pins
       end
 
       def infer_self context_pin
@@ -109,7 +122,8 @@ module Solargraph
         namespace = api_map.qualify(relname, context_pin.namespace)
         visibility = [:public]
         visibility.push :protected, :private if internal
-        result = api_map.get_methods(namespace, scope: scope, visibility: visibility).select{|pin| pin.name == method_name}
+        # result = api_map.get_methods(namespace, scope: scope, visibility: visibility).select{|pin| pin.name == method_name}
+        result = api_map.get_method_stack(namespace, method_name, scope: scope).select{|pin| visibility.include?(pin.visibility)}
         # @todo This needs more rules. Probably need to update YardObject for it.
         return result if result.empty?
         return result unless method_name == 'new' and result.first.path == 'Class#new'
@@ -165,9 +179,8 @@ module Solargraph
       #
       # @return [Pin::Method]
       def virtual_new_pin new_pin, context_pin
-        pin = Pin::Method.new(new_pin.location, new_pin.namespace, new_pin.name, new_pin.docstring, new_pin.scope, new_pin.visibility, new_pin.parameters)
+        pin = Pin::Method.new(new_pin.location, context_pin.path, new_pin.name, '', :class, new_pin.visibility, new_pin.parameters)
         # @todo Smelly instance variable access.
-        # pin.instance_variable_set(:@return_type, context_pin.path)
         pin.instance_variable_set(:@return_complex_types, ComplexType.parse(context_pin.path))
         pin
       end
@@ -177,6 +190,7 @@ module Solargraph
       # @return [String]
       def resolve_pin_type pin, locals
         return pin.return_type unless pin.return_type.nil?
+        return pin.namespace if pin.kind == Pin::METHOD and pin.name == 'new' and pin.scope == :class
         return resolve_block_parameter(pin, locals) if pin.kind == Pin::BLOCK_PARAMETER
         return resolve_method_parameter(pin) if pin.is_a?(Pin::MethodParameter)
         return resolve_variable(pin, locals) if pin.variable?
@@ -201,21 +215,18 @@ module Solargraph
           return nil if subtypes.nil?
           return subtypes[0]
         else
-          unless meth.docstring.nil?
-            yps = meth.docstring.tags(:yieldparam)
-            unless yps[pin.index].nil? or yps[pin.index].types.nil? or yps[pin.index].types.empty?
-              return yps[pin.index].types[0]
-            end
+          yps = meth.docstring.tags(:yieldparam)
+          unless yps[pin.index].nil? or yps[pin.index].types.nil? or yps[pin.index].types.empty?
+            return yps[pin.index].types[0]
           end
         end
         nil
       end
 
       def resolve_method_parameter pin
-        matches = api_map.get_methods(pin.namespace, scope: pin.scope, visibility: [:public, :private, :protected]).select{|p| p.name == pin.context.name}
+        matches = api_map.get_method_stack(pin.namespace, pin.context.name, scope: pin.scope)
         matches.each do |m|
           next unless pin.context.parameters == m.parameters
-          next if m.docstring.nil?
           tag = m.docstring.tags(:param).select{|t| t.name == pin.name}.first
           next if tag.nil? or tag.types.nil?
           return tag.types[0]