solargraph 0.18.3 → 0.19.0

data/lib/solargraph/api_map.rb

@@ -7,6 +7,8 @@ module Solargraph
     autoload :Cache,        'solargraph/api_map/cache'
     autoload :SourceToYard, 'solargraph/api_map/source_to_yard'
     autoload :Completion,   'solargraph/api_map/completion'
+    autoload :Probe,        'solargraph/api_map/probe'
+    autoload :Store,        'solargraph/api_map/store'
 
     include Solargraph::ApiMap::SourceToYard
     include CoreFills
@@ -17,27 +19,41 @@ module Solargraph
     attr_reader :workspace
 
     # @param workspace [Solargraph::Workspace]
-    def initialize workspace = nil
-      # @todo Deprecate strings for the workspace parameter
-      workspace = Solargraph::Workspace.new(workspace) if workspace.kind_of?(String)
-      workspace = Solargraph::Workspace.new(nil) if workspace.nil?
+    def initialize workspace = Solargraph::Workspace.new(nil)
       @workspace = workspace
       require_extensions
       @virtual_source = nil
       @yard_stale = true
-      process_maps
+      # process_maps
+      @sources = workspace.sources
       yard_map
     end
 
+    # Create an ApiMap with a workspace in the specified directory.
+    #
+    # @return [ApiMap]
     def self.load directory
       self.new(Solargraph::Workspace.new(directory))
     end
 
+    # @return [ApiMap::Store]
+    def store
+      @store ||= ApiMap::Store.new(@sources)
+    end
+
+    def pins
+      store.pins
+    end
+
     # An array of required paths in the workspace.
     #
     # @return [Array<String>]
     def required
-      @required ||= []
+      result = []
+      @sources.each do |s|
+        result.concat s.required
+      end
+      result.uniq
     end
 
     # Get a YardMap associated with the current workspace.
@@ -65,8 +81,9 @@ module Solargraph
     # one source can be virtualized at a time.
     #
     # @param source [Solargraph::Source]
+    # @return [Solargraph::Source]
     def virtualize source
-      eliminate @virtual_source unless @virtual_source.nil?
+      store.remove @virtual_source unless @virtual_source.nil?
       if workspace.has_source?(source)
         @sources = workspace.sources
         @virtual_source = nil
@@ -78,10 +95,18 @@ module Solargraph
           process_virtual
         end
       end
+      source
     end
 
-    # @todo Candidate for deprecation
-    def append_source code, filename = nil
+    # Create a Source from the code and filename, and virtualize the result.
+    # This method can be useful for directly testing the ApiMap. In practice,
+    # applications should use a Library to synchronize the ApiMap to a
+    # workspace.
+    #
+    # @param code [String]
+    # @param filename [String]
+    # @return [Solargraph::Source]
+    def virtualize_string code, filename = nil
       source = Source.load_string(code, filename)
       virtualize source
     end
@@ -92,27 +117,12 @@ module Solargraph
     def refresh force = false
       return unless @force or changed?
       if force
-        process_maps
+        @api_map = ApiMap::Store.new(@sources)
       else
-        current_workspace_sources.reject{|s| workspace.sources.include?(s)}.each do |source|
-          eliminate source
-        end
+        store.remove *(current_workspace_sources.reject{ |s| workspace.sources.include?(s) })
         @sources = workspace.sources
         @sources.push @virtual_source unless @virtual_source.nil?
-        cache.clear
-        namespace_map.clear
-        @sources.each do |s|
-          s.namespaces.each do |n|
-            namespace_map[n] ||= []
-            namespace_map[n].concat s.namespace_pins(n)
-          end
-        end
-        @sources.each do |source|
-          if @stime.nil? or source.stime > @stime
-            eliminate source
-            map_source source
-          end
-        end
+        store.update *(@sources.select{ |s| @stime.nil? or s.stime > @stime })
       end
       @stime = Time.new
     end
@@ -142,8 +152,7 @@ module Solargraph
     #
     # @return [Array<String>]
     def namespaces
-      # refresh
-      namespace_map.keys
+      store.namespaces
     end
 
     # True if the namespace exists.
@@ -152,14 +161,14 @@ module Solargraph
     # @param root [String] The context to search
     # @return [Boolean]
     def namespace_exists? name, root = ''
-      !find_fully_qualified_namespace(name, root).nil?
+      !qualify(name, root).nil?
     end
 
     # Get suggestions for constants in the specified namespace. The result
     # may contain both constant and namespace pins.
     #
-    # @param fqns [String] The fully qualified namespace
-    # @param visibility [Array<Symbol>] :public and/or :private
+    # @param namespace [String] The namespace
+    # @param context [String] The context
     # @return [Array<Solargraph::Pin::Base>]
     def get_constants namespace, context = ''
       namespace ||= ''
@@ -168,13 +177,13 @@ module Solargraph
       bases = context.split('::')
       while bases.length > 0
         built = bases.join('::')
-        fqns = find_fully_qualified_namespace(namespace, built)
+        fqns = qualify(namespace, built)
         visibility = [:public]
         visibility.push :private if fqns == context
         result.concat inner_get_constants(fqns, visibility, skip)
         bases.pop
       end
-      fqns = find_fully_qualified_namespace(namespace, '')
+      fqns = qualify(namespace, '')
       visibility = [:public]
       visibility.push :private if fqns == context
       result.concat inner_get_constants(fqns, visibility, skip)
@@ -182,54 +191,18 @@ module Solargraph
     end
 
     # Get a fully qualified namespace name. This method will start the search
-    # in the specified root until it finds a match for the name.
+    # in the specified context until it finds a match for the name.
     #
-    # @param name [String] The namespace to match
-    # @param root [String] The context to search
+    # @param namespace [String] The namespace to match
+    # @param context [String] The context to search
     # @return [String]
-    def find_fully_qualified_namespace name, root = '', skip = []
-      # refresh
-      return nil if name.nil?
-      return nil if skip.include?(root)
-      skip.push root
-      if name == ''
-        if root == ''
-          return ''
-        else
-          return find_fully_qualified_namespace(root, '', skip)
-        end
-      else
-        if (root == '')
-          return name unless namespace_map[name].nil?
-          im = @namespace_includes['']
-          unless im.nil?
-            im.each do |i|
-              i.resolve self
-              return i.name unless i.name.nil?
-            end
-          end
-        else
-          roots = root.to_s.split('::')
-          while roots.length > 0
-            fqns = roots.join('::') + '::' + name
-            return fqns unless namespace_map[fqns].nil?
-            roots.pop
-          end
-          return name unless namespace_map[name].nil?
-          im = @namespace_includes['']
-          unless im.nil?
-            im.each do |i|
-              i.resolve self
-              return i.name unless i.name.nil?
-            end
-          end
-        end
-      end
-      result = yard_map.find_fully_qualified_namespace(name, root)
-      if result.nil?
-        result = live_map.get_fqns(name, root)
-      end
-      result
+    def qualify namespace, context = ''
+      inner_qualify namespace, context, []
+    end
+
+    # @deprecated Use #qualify instead
+    def find_fully_qualified_namespace namespace, context = ''
+      qualify namespace, context
     end
 
     # Get an array of instance variable pins defined in specified namespace
@@ -239,13 +212,7 @@ module Solargraph
     # @param scope [Symbol] :instance or :class
     # @return [Array<Solargraph::Pin::InstanceVariable>]
     def get_instance_variable_pins(namespace, scope = :instance)
-      raw = @ivar_pins[namespace]
-      return [] if raw.nil?
-      # @todo This is a crazy workaround because instance variables in the
-      #   global namespace might be in either scope
-      pins = prefer_non_nil_variables(raw)
-      return pins if namespace.empty?
-      pins.select{ |pin| pin.scope == scope }
+      store.get_instance_variables(namespace, scope)
     end
 
     # Get an array of class variable pins for a namespace.
@@ -258,221 +225,7 @@ module Solargraph
 
     # @return [Array<Solargraph::Pin::Base>]
     def get_symbols
-      # refresh
-      @symbol_pins
-    end
-
-    # Find a class, instance, or global variable by name in the provided
-    # namespace and scope.
-    #
-    # @param name [String] The variable name, e.g., `@foo`, `@@bar`, or `$baz`
-    # @param fqns [String] The fully qualified namespace
-    # @param scope [Symbol] :class or :instance
-    # @return [Solargraph::Pin::BaseVariable]
-    def find_variable_pin name, fqns, scope
-      var = nil
-      return nil if name.nil?
-      if name.start_with?('@@')
-        # class variable
-        var = get_class_variable_pins(fqns).select{|pin| pin.name == name}.first
-        return nil if var.nil?
-      elsif name.start_with?('@')
-        # instance variable
-        var = get_instance_variable_pins(fqns, scope).select{|pin| pin.name == name}.first
-        return nil if var.nil?
-      elsif name.start_with?('$')
-        # global variable
-        var = get_global_variable_pins.select{|pin| pin.name == name}.first
-        return nil if var.nil?
-      end
-      var
-    end
-
-    def find_namespace_pin fqns
-      crawl_constants fqns, '', [:public, :private]
-    end
-
-    def crawl_constants name, fqns, visibility
-      return nil if name.nil?
-      chain = name.split('::')
-      cursor = chain.shift
-      return nil if cursor.nil?
-      unless fqns.empty?
-        bases = fqns.split('::')
-        result = nil
-        until bases.empty?
-          built = bases.join('::')
-          result = get_constants(built, '').select{|pin| pin.name == cursor and visibility.include?(pin.visibility)}.first
-          break unless result.nil?
-          bases.pop
-          visibility -= [:private]
-        end
-        return nil if result.nil?
-      end
-      result = get_constants(fqns, '').select{|pin| pin.name == cursor and visibility.include?(pin.visibility)}.first
-      visibility -= [:private]
-      until chain.empty? or result.nil?
-        fqns = result.path
-        cursor = chain.shift
-        result = get_constants(fqns, '').select{|pin| pin.name == cursor and visibility.include?(pin.visibility)}.first
-      end
-      result
-    end
-
-    # This method checks the signature from the namespace's internal context,
-    # i.e., the first word in the signature can be a private or protected
-    # method, a private constant, an instance variable, or a class variable.
-    # Local variables are not accessible.
-    #
-    # @return [String]
-    def infer_type signature, namespace = '', scope: :instance
-      context = combine_type(namespace, scope)
-      parts = signature.split('.')
-      base = parts.shift
-      return nil if base.nil?
-      type = infer_word_type(base, context, true)
-      return nil if type.nil?
-      until parts.empty?
-        word = parts.shift
-        type = infer_method_type(word, type)
-        return nil if type.nil?
-      end
-      type
-    end
-
-    # @return [Solargraph::Pin::Base]
-    def tail_pins signature, fqns, scope, visibility
-      return [] if signature.nil?
-      type = combine_type(fqns, scope)
-      return infer_word_pins(signature, type, true) unless signature.include?('.')
-      parts = signature.split('.')
-      last = parts.pop
-      base = parts.join('.')
-      type = infer_type(base, fqns, scope: scope)
-      return [] if type.nil?
-      infer_word_pins(last, type, true)
-    end
-
-    # @return [Solargraph::Pin::Base]
-    def tail_pin signature, fqns, scope, visibility
-      tail_pins(signature, fqns, scope, visibility).first
-    end
-
-    # Get an array of pins for a word in the provided context. A word can be
-    # a constant, a global variable, or a method name. Private and protected
-    # words are excluded by default. Set the `internal` parameter to `true` to
-    # to include private and protected methods, private constants, instance
-    # variables, and class variables.
-    #
-    # @param word [String]
-    # @param base_type [String]
-    # @param internal [Boolean]
-    # @return [Array<Solargraph::Pin::Base>]
-    def infer_word_pins word, base_type, internal = false
-      pins = []
-      namespace, scope = extract_namespace_and_scope(base_type)
-      if word == 'self' and internal
-        context = (internal ? namespace.split('::')[0..-2].join(';;') : '')
-        fqns = find_fully_qualified_namespace(namespace, context)
-        pins.concat get_path_suggestions(fqns) unless fqns.nil?
-        return pins
-      end
-      fqns = find_fully_qualified_namespace(word, namespace)
-      unless fqns.nil?
-        pins.concat get_path_suggestions(fqns) unless fqns.nil?
-        return pins
-      end
-      if internal
-        if word.start_with?('@@')
-          pins.concat get_class_variable_pins(namespace).select{|pin| pin.name == word}
-          return pins
-        elsif word.start_with?('@')
-          pins.concat get_instance_variable_pins(namespace, scope).select{|pin| pin.name == word}
-          return pins
-        end
-      end
-      if word.start_with?('$')
-        pins.concat get_global_variable_pins.select{|pin| pin.name == word}
-        return pins
-      end
-      pins.concat get_constants(namespace, (internal ? namespace : '')).select{|pin| pin.name == word}
-      if pins.empty?
-        pins.concat get_type_methods(base_type, (internal ? base_type : '')).select{|pin| pin.name == word}
-        pins.concat get_type_methods('Kernel').select{|pin| pin.name == word}
-      end
-      pins
-    end
-
-    # @return [Solargraph::Pin::Base]
-    def infer_word_pin word, base_type, internal = false
-      infer_word_pins(word, base_type, internal).first
-    end
-
-    # @return [String]
-    def infer_word_type word, base_type, internal = false
-      return base_type if word == 'self' and internal
-      if word == 'new'
-        namespace, scope = extract_namespace_and_scope(base_type)
-        return namespace if scope == :class
-      end
-      pin = infer_word_pin(word, base_type, internal)
-      return nil if pin.nil?
-      pin.resolve self
-      pin.return_type
-    end
-
-    # Get an array of pins for a method name in the provided context. Private
-    # and protected methods are excluded by default. Set the `internal`
-    # parameter to `true` to include all methods.
-    #
-    # @param method_name [String] The name of the method
-    # @param base_type [String] The context type (e.g., `String` or `Class<String>`)
-    # @param internal [Boolean] True if the call came from inside the base type
-    # @return [Array<Solargraph::Pin::Base>]
-    def infer_method_pins method_name, base_type, internal = false
-      get_type_methods(base_type, (internal ? base_type : '')).select{|pin| pin.name == method_name}
-    end
-
-    # Get the first pin that matches a method name in the provided context.
-    # Private and protected methods are excluded by default. Set the `internal`
-    # parameter to `true` to include all methods.
-    #
-    # @param method_name [String] The name of the method
-    # @param base_type [String] The context type (e.g., `String` or `Class<String>`)
-    # @param internal [Boolean] True if the call came from inside the base type
-    # @return [Solargraph::Pin::Base]
-    def infer_method_pin method_name, base_type, internal = false
-      infer_method_pins(method_name, base_type, internal).first
-    end
-
-    # Infer the type returned by a method in the provided context. Private and
-    # protected methods are excluded by default. Set the `internal` parameter
-    # to `true` to include all methods.
-    #
-    # @param method_name [String] The name of the method
-    # @param base_type [String] The context type (e.g., `String` or `Class<String>`)
-    # @param internal [Boolean] True if the call came from inside the base type
-    # @return [String]
-    def infer_method_type method_name, base_type, internal = false
-      namespace, scope = extract_namespace_and_scope(base_type)
-      method = infer_method_pin(method_name, base_type, internal)
-      return nil if method.nil?
-      method.resolve self
-      return namespace if method.name == 'new' and scope == :class
-      return base_type if method.return_type == 'self'
-      method.return_type
-    end
-
-    def infer_deep_signature_type chain, base_type
-      return nil if base_type.nil?
-      internal = true
-      until chain.empty?
-        base = chain.shift
-        base_type = infer_method_type(base, base_type, internal)
-        return nil if base_type.nil?
-        internal = false
-      end
-      base_type
+      store.get_symbols
     end
 
     # @return [Array<Solargraph::Pin::GlobalVariable>]
@@ -484,17 +237,6 @@ module Solargraph
       globals
     end
 
-    def get_type_methods type, context = ''
-      return [] if type.nil?
-      namespace, scope = extract_namespace_and_scope(type)
-      base = extract_namespace(context)
-      fqns = find_fully_qualified_namespace(namespace, base)
-      return [] if fqns.nil?
-      visibility = [:public]
-      visibility.push :private, :protected if fqns == base
-      get_methods fqns, scope: scope, visibility: visibility
-    end
-
     def get_methods fqns, scope: :instance, visibility: [:public], deep: true
       result = []
       skip = []
@@ -511,9 +253,9 @@ module Solargraph
     # @param fragment [Solargraph::Source::Fragment]
     # @return [ApiMap::Completion]
     def complete fragment
-      return Completion.new([], fragment.whole_word_range) if fragment.string? or fragment.comment? or fragment.calculated_signature.start_with?('.')
+      return Completion.new([], fragment.whole_word_range) if fragment.string? or fragment.comment?
       result = []
-      if !fragment.signature.include?('.')
+      if !fragment.signature.include?('.') and !fragment.base_literal?
         if fragment.signature.start_with?('@@')
           result.concat get_class_variable_pins(fragment.namespace)
         elsif fragment.signature.start_with?('@')
@@ -524,34 +266,38 @@ module Solargraph
           result.concat get_symbols
         else
           unless fragment.signature.include?('::')
-            result.concat prefer_non_nil_variables(fragment.local_variable_pins)
-            result.concat get_type_methods(combine_type(fragment.namespace, fragment.scope), fragment.namespace)
-            result.concat get_type_methods('Kernel')
+            result.concat prefer_non_nil_variables(fragment.locals)
+            result.concat get_methods(fragment.namespace, scope: fragment.scope, visibility: [:public, :private, :protected])
+            result.concat get_methods('Kernel')
             result.concat ApiMap.keywords
           end
           result.concat get_constants(fragment.base, fragment.namespace)
         end
       else
-        if fragment.signature.include?('::') and !fragment.signature.include?('.')
-          result.concat get_constants(fragment.calculated_base, fragment.namespace)
-        else
-          if fragment.calculated_signature.end_with?('.')
-            rest = fragment.calculated_signature.split('.')
-          else
-            rest = fragment.calculated_base.split('.')
+        if fragment.base_literal?
+          pin = get_path_suggestions(fragment.base_literal).select{|pin| pin.kind == Pin::NAMESPACE}.first
+          unless pin.nil?
+            if fragment.base.empty?
+              result.concat get_methods(pin.path)
+            else
+              type = probe.infer_signature_type(fragment.base, pin, fragment.locals)
+              unless type.nil?
+                namespace, scope = extract_namespace_and_scope(type)
+                result.concat get_methods(namespace, scope: scope)
+              end
+            end
           end
-          base = rest.shift
-          type = infer_word_type(base, fragment.namespace, scope: fragment.scope)
+        elsif fragment.signature.include?('::') and !fragment.signature.include?('.')
+          result.concat get_constants(fragment.base, fragment.namespace)
+        else
+          type = probe.infer_signature_type(fragment.base, fragment.named_path, fragment.locals)
           unless type.nil?
-            rest.each do |m|
-              type = infer_method_type(m, type)
-              next if type.nil?
-            end
-            result.concat get_type_methods(type) unless type.nil?
+            namespace, scope = extract_namespace_and_scope(type)
+            result.concat get_methods(namespace, scope: scope)
           end
         end
       end
-      filtered = result.uniq(&:identifier).select{|s| s.kind != Solargraph::LanguageServer::CompletionItemKinds::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.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
 
@@ -559,74 +305,25 @@ module Solargraph
     # @return [Array<Solargraph::Pin::Base>]
     def define fragment
       return [] if fragment.string? or fragment.comment?
-      tail_pins fragment.whole_signature, fragment.namespace, fragment.scope, [:public, :private, :protected]
-    end
-
-    def infer_fragment_type fragment
-      parts = fragment.whole_signature.split('.')
-      base = parts.shift
-      type = nil
-      lvar = prefer_non_nil_variables(fragment.local_variable_pins(base)).first
-      unless lvar.nil?
-        lvar.resolve self
-        type = lvar.return_type
-        return nil if type.nil?
-      end
-      type = infer_word_type(base, fragment.namespace, fragment.scope) if type.nil?
-      return nil if type.nil?
-      until parts.empty?
-        meth = parts.shift
-        type = infer_word_type(meth, type)
-        return nil if type.nil?
-      end
-      type
+      probe.infer_signature_pins fragment.whole_signature, fragment.named_path, fragment.locals
     end
 
+    # Infer a return type from a fragment. This method will attempt to resolve
+    # signatures.
+    #
     # @param fragment [Solargraph::Source::Fragment]
+    # @return [String]
+    def infer_type fragment
+      return nil if fragment.string? or fragment.comment?
+      probe.infer_signature_type fragment.whole_signature, fragment.named_path, fragment.locals
+    end
+
+    # @param fragment [Solargraph::Source::Fragment]
+    # @return [Array<Solargraph::Pin::Base>]
     def signify fragment
       return [] unless fragment.argument?
       return [] if fragment.recipient.whole_signature.nil? or fragment.recipient.whole_signature.empty?
-      base, rest = fragment.recipient.whole_signature.split('.', 2)
-      return infer_word_pins(base, fragment.recipient.namespace, true) if rest.nil?
-      type = nil
-      lvar = prefer_non_nil_variables(fragment.local_variable_pins(base)).first
-      unless lvar.nil?
-        lvar.resolve self
-        type = lvar.return_type
-        return [] if type.nil?
-      end
-      type = infer_word_type(base, fragment.namespace, fragment.scope) if type.nil?
-      return [] if type.nil?
-      ns, sc = extract_namespace_and_scope(type)
-      tail_pins(rest, ns, sc, [:public, :private, :protected])
-    end
-
-    # Get the namespace's type (Class or Module).
-    #
-    # @param [String] A fully qualified namespace
-    # @return [Symbol] :class, :module, or nil
-    def get_namespace_type fqns
-      pin = @namespace_path_pins[fqns]
-      return yard_map.get_namespace_type(fqns) if pin.nil?
-      pin.first.type
-    end
-
-    # Convert a namespace and scope into a type.
-    #
-    # @example
-    #   combine_type('String', :instance) => 'String'
-    #   combine_type('String', :class)    => 'Class<String>'
-    #
-    # @param namespace [String]
-    # @param scope [Symbol] :class or :instance
-    def combine_type namespace, scope
-      return '' if namespace.empty?
-      if scope == :instance
-        namespace
-      else
-        type = get_namespace_type(namespace)
-        "#{type == :class ? 'Class' : 'Module'}<#{namespace}>"
-      end
+      probe.infer_signature_pins fragment.recipient.whole_signature, fragment.named_path, fragment.locals
     end
 
     # Get an array of all suggestions that match the specified path.
@@ -635,28 +332,10 @@ module Solargraph
     # @return [Array<Solargraph::Pin::Base>]
     def get_path_suggestions path
       return [] if path.nil?
-      # refresh
       result = []
-      if path.include?('#')
-        # It's an instance method
-        parts = path.split('#')
-        result = get_methods(parts[0], visibility: [:public, :private, :protected]).select{|s| s.name == parts[1]}
-      elsif path.include?('.')
-        # It's a class method
-        parts = path.split('.')
-        result = get_methods(parts[0], scope: :class, visibility: [:public, :private, :protected]).select{|s| s.name == parts[1]}
-      else
-        # It's a class or module
-        parts = path.split('::')
-        np = @namespace_pins[parts[0..-2].join('::')]
-        unless np.nil?
-          result.concat np.select{|p| p.name == parts.last}
-        end
-        result.concat yard_map.objects(path)
-      end
-      # @todo Resolve the pins?
-      result.map{|pin| pin.resolve(self); pin}
-      # result
+      result.concat store.get_path_pins(path)
+      result.concat yard_map.objects(path)
+      result
     end
 
     # Get a list of documented paths that match the query.
@@ -702,145 +381,33 @@ module Solargraph
       result
     end
 
-    def superclass_of fqns
-      found = @superclasses[fqns]
-      return nil if found.nil?
-      found.resolve self
-      found.name
-    end
-
     def locate_pin location
       @sources.each do |source|
         pin = source.locate_pin(location)
         unless pin.nil?
-          pin.resolve self
+          # pin.resolve self
           return pin
         end
       end
       nil
     end
 
-    private
-
-    # @return [Hash]
-    def namespace_map
-      @namespace_map ||= {}
+    # @return [Probe]
+    def probe
+      @probe ||= Probe.new(self)
     end
 
-    def process_maps
-      @sources = workspace.sources
-      @sources.push @virtual_source unless @virtual_source.nil?
-      cache.clear
-      @ivar_pins = {}
-      @cvar_pins = {}
-      @const_pins = {}
-      @method_pins = {}
-      @symbol_pins = []
-      @attr_pins = {}
-      @namespace_includes = {}
-      @namespace_extends = {}
-      @superclasses = {}
-      @namespace_pins = {}
-      @namespace_path_pins = {}
-      namespace_map.clear
-      @required = workspace.config.required.clone
-      @sources.each do |s|
-        s.namespaces.each do |n|
-          namespace_map[n] ||= []
-          namespace_map[n].concat s.namespace_pins(n)
-        end
-      end
-      @sources.each do |s|
-        map_source s
-      end
-      @required.uniq!
-      live_map.refresh
-      @yard_stale = true
-      @stime = Time.now
-    end
-
-    def rebuild_local_yardoc
-      return if workspace.nil? or !File.exist?(File.join(workspace, '.yardoc'))
-      STDERR.puts "Rebuilding local yardoc for #{workspace}"
-      Dir.chdir(workspace) { Process.spawn('yardoc') }
-    end
+    private
 
     def process_virtual
       unless @virtual_source.nil?
-        cache.clear
-        namespace_map.clear
-        @sources.each do |s|
-          s.namespace_pins.each do |pin|
-            namespace_map[pin.path] ||= []
-            namespace_map[pin.path].push pin
-          end
-        end
         map_source @virtual_source
       end
     end
 
-    def eliminate source
-      [@ivar_pins.values, @cvar_pins.values, @const_pins.values, @method_pins.values, @attr_pins.values, @namespace_pins.values].each do |pinsets|
-        pinsets.each do |pins|
-          pins.delete_if{|pin| pin.filename == source.filename}
-        end
-      end
-      [@namespace_includes.values, @namespace_extends.values].each do |refsets|
-        refsets.each do |refs|
-          refs.delete_if{|ref| ref.pin.filename == source.filename}
-        end
-      end
-      @superclasses.delete_if{|key, ref| ref.pin.filename == source.filename}
-      @symbol_pins.delete_if{|pin| pin.filename == source.filename}
-    end
-
     # @param [Solargraph::Source]
     def map_source source
-      source.method_pins.each do |pin|
-        @method_pins[pin.namespace] ||= []
-        @method_pins[pin.namespace].push pin
-      end
-      source.attribute_pins.each do |pin|
-        @attr_pins[pin.namespace] ||= []
-        @attr_pins[pin.namespace].push pin
-      end
-      source.instance_variable_pins.each do |pin|
-        @ivar_pins[pin.namespace] ||= []
-        @ivar_pins[pin.namespace].push pin
-      end
-      source.class_variable_pins.each do |pin|
-        @cvar_pins[pin.namespace] ||= []
-        @cvar_pins[pin.namespace].push pin
-      end
-      source.constant_pins.each do |pin|
-        @const_pins[pin.namespace] ||= []
-        @const_pins[pin.namespace].push pin
-      end
-      source.symbol_pins.each do |pin|
-        @symbol_pins.push pin
-      end
-      source.namespace_pins.each do |pin|
-        @namespace_path_pins[pin.path] ||= []
-        @namespace_path_pins[pin.path].push pin
-        @namespace_pins[pin.namespace] ||= []
-        @namespace_pins[pin.namespace].push pin
-        # @todo Determine whether references should be resolve here or
-        #   dynamically during queries
-        unless pin.superclass_reference.nil?
-          @superclasses[pin.path] = pin.superclass_reference
-          # pin.superclass_reference.resolve self
-        end
-        pin.include_references.each do |ref|
-          @namespace_includes[pin.path] ||= []
-          @namespace_includes[pin.path].push ref
-          # ref.resolve self
-        end
-        pin.extend_references.each do |ref|
-          @namespace_extends[pin.path] ||= []
-          @namespace_extends[pin.path].push ref
-          # ref.resolve self
-        end
-      end
+      store.update source
       path_macros.merge! source.path_macros
       source.required.each do |r|
         required.push r
@@ -858,44 +425,28 @@ module Solargraph
       skip.push reqstr
       result = []
       if scope == :instance
-        aps = @attr_pins[fqns]
-        result.concat aps unless aps.nil?
-      end
-      mps = @method_pins[fqns]
-      result.concat mps.select{|pin| (pin.scope == scope or fqns == '') and visibility.include?(pin.visibility)} unless mps.nil?
-      if fqns != '' and scope == :class and !result.map(&:path).include?("#{fqns}.new")
-        # Create a [Class].new method pin from [Class]#initialize
-        init = inner_get_methods(fqns, :instance, [:private], deep, skip - [fqns]).select{|pin| pin.name == 'initialize'}.first
-        unless init.nil?
-          result.unshift Solargraph::Pin::Directed::Method.new(init.source, init.node, init.namespace, :class, :public, init.docstring, 'new', init.namespace)
-        end
+        result.concat store.get_attrs(fqns)
       end
+      result.concat store.get_methods(fqns, scope: scope, visibility: visibility)
       if deep
-        scref = @superclasses[fqns]
-        unless scref.nil?
+        sc = store.get_superclass(fqns)
+        unless sc.nil?
+          fqsc = qualify(sc, fqns)
           sc_visi = [:public]
           sc_visi.push :protected if visibility.include?(:protected)
-          # sc_fqns = find_fully_qualified_namespace(sc, fqns)
-          scref.resolve self
-          result.concat inner_get_methods(scref.name, scope, sc_visi, true, skip) unless scref.name.nil?
+          result.concat inner_get_methods(fqsc, scope, sc_visi, true, skip) unless fqsc.nil?
         end
         if scope == :instance
-          im = @namespace_includes[fqns]
-          unless im.nil?
-            im.each do |i|
-              i.resolve self
-              result.concat inner_get_methods(i.name, scope, visibility, deep, skip) unless i.name.nil?
-            end
+          store.get_includes(fqns).each do |im|
+            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 inner_get_methods('Object', :instance, [:public], deep, skip) unless fqns == 'Object'
         else
-          em = @namespace_extends[fqns]
-          unless em.nil?
-            em.each do |e|
-              e.resolve self
-              result.concat inner_get_methods(e.name, :instance, visibility, deep, skip) unless e.name.nil?
-            end
+          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)
           type = get_namespace_type(fqns)
@@ -913,49 +464,15 @@ module Solargraph
       return [] if skip.include?(fqns)
       skip.push fqns
       result = []
-      result.concat @const_pins[fqns] if @const_pins.has_key?(fqns)
-      result.concat @namespace_pins[fqns] if @namespace_pins.has_key?(fqns)
-      result.keep_if{|pin| !pin.name.empty? and visibility.include?(pin.visibility)}
+      result.concat store.get_constants(fqns, visibility)
       result.concat yard_map.get_constants(fqns)
-      is = @namespace_includes[fqns]
-      unless is.nil?
-        is.each do |i|
-          i.resolve self
-          result.concat inner_get_constants(i.name, [:public], skip) unless i.name.nil?
-        end
+      store.get_includes(fqns).each do |is|
+        fqis = qualify(is, fqns)
+        result.concat inner_get_constants(fqis, [:public], skip) unless fqis.nil?
       end
       result
     end
 
-    # Extract a namespace from a type.
-    #
-    # @example
-    #   extract_namespace('String') => 'String'
-    #   extract_namespace('Class<String>') => 'String'
-    #
-    # @return [String]
-    def extract_namespace type
-      extract_namespace_and_scope(type)[0]
-    end
-
-    # Extract a namespace and a scope (:instance or :class) from a type.
-    #
-    # @example
-    #   extract_namespace('String')            #=> ['String', :instance]
-    #   extract_namespace('Class<String>')     #=> ['String', :class]
-    #   extract_namespace('Module<Enumerable') #=> ['Enumberable', :class]
-    #
-    # @return [Array] The namespace (String) and scope (Symbol).
-    def extract_namespace_and_scope type
-      scope = :instance
-      result = type.to_s.gsub(/<.*$/, '')
-      if (result == 'Class' or result == 'Module') and type.include?('<')
-        result = type.match(/<([a-z0-9:_]*)/i)[1]
-        scope = :class
-      end
-      [result, scope]
-    end
-
     def require_extensions
       Gem::Specification.all_names.select{|n| n.match(/^solargraph\-[a-z0-9_\-]*?\-ext\-[0-9\.]*$/)}.each do |n|
         STDERR.puts "Loading extension #{n}"
@@ -968,7 +485,7 @@ module Solargraph
       result = []
       nil_pins = []
       pins.each do |pin|
-        if pin.nil_assignment? and pin.return_type.nil?
+        if pin.variable? and pin.nil_assignment?
           nil_pins.push pin
         else
           result.push pin
@@ -977,14 +494,6 @@ module Solargraph
       result + nil_pins
     end
 
-    # @todo DRY this method. It's duplicated in CodeMap
-    def get_subtypes type
-      return [] if type.nil?
-      match = type.match(/<([a-z0-9_:, ]*)>/i)
-      return [] if match.nil?
-      match[1].split(',').map(&:strip)
-    end
-
     # @return [Hash]
     def path_macros
       @path_macros ||= {}
@@ -993,5 +502,56 @@ module Solargraph
     def current_workspace_sources
       @sources - [@virtual_source]
     end
+
+    def inner_qualify name, root, skip
+      return nil if name.nil?
+      return nil if skip.include?(root)
+      skip.push root
+      if name == ''
+        if root == ''
+          return ''
+        else
+          return inner_qualify(root, '', skip)
+        end
+      else
+        if (root == '')
+          return name if store.namespace_exists?(name)
+          # @todo What to do about the @namespace_includes stuff above?
+        else
+          roots = root.to_s.split('::')
+          while roots.length > 0
+            fqns = roots.join('::') + '::' + name
+            return fqns if store.namespace_exists?(fqns)
+            roots.pop
+          end
+          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
+    end
+
+    # Get the namespace's type (Class or Module).
+    #
+    # @param [String] A fully qualified namespace
+    # @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?
+      pin.type
+    end
+
+    def extract_namespace_and_scope type
+      scope = :instance
+      result = type.to_s.gsub(/<.*$/, '')
+      if (result == 'Class' or result == 'Module') and type.include?('<')
+        result = type.match(/<([a-z0-9:_]*)/i)[1]
+        scope = :class
+      end
+      [result, scope]
+    end
   end
 end