solargraph 0.26.1 → 0.27.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 54749425491eea537bc8a0ef4878e21fd17aee1c88e3575a44fecbdbfe323498
-  data.tar.gz: 2c61f75cb843a534dc8779245a5395f3d38f411efd3cb0350cfc473b53d7e290
+  metadata.gz: 46fca036521e6830f95550138d35e1c504cec3f75c04b45ff9ce3cf06cbafc30
+  data.tar.gz: 32fd1c0b308a3c5b89f00bbd4b8f804aba057d8277ccafb5505f7e787dca3fb3
 SHA512:
-  metadata.gz: 76bb57c0cc0843d3a71c8ee3afa65d4f14282455d43f3fcd0fa471387ff547873476cb39c5164f8ea0499d1586d7e34f1dbb14c701c7aab02abfc9de06fad676
-  data.tar.gz: 37cc582ea792270dbe447e356b575ef2d81e76b4af9805428048589b59ef0a6f20a3c70b169631a83a1fdfb328b0ce39550b14d497fb5aad6b8f89b67a2c5a96
+  metadata.gz: '07263532728a958734568023619dedbd8b2fcc1c5b84aa9a4432c4af8c247f5cf47343861ee15ef8b377371c35ed96e05367d34781fbb49b1dcf120cc5f1893b'
+  data.tar.gz: 1bc3fddcfc98cee8f0287b46e1792f4ff87c51c45bc6ed1281e88ea8473470ef062eebe2e3ac112d63d639c647015c702072840732464b271f68574cf329cf66

data/lib/solargraph.rb

@@ -24,8 +24,12 @@ module Solargraph
     end
   end
 
+  autoload :Position,         'solargraph/position'
+  autoload :Range,            'solargraph/range'
+  autoload :Location,         'solargraph/location'
   autoload :Shell,            'solargraph/shell'
   autoload :Source,           'solargraph/source'
+  autoload :SourceMap,        'solargraph/source_map'
   autoload :ApiMap,           'solargraph/api_map'
   autoload :YardMap,          'solargraph/yard_map'
   autoload :Pin,              'solargraph/pin'
@@ -38,9 +42,8 @@ module Solargraph
   autoload :Page,             'solargraph/page'
   autoload :Library,          'solargraph/library'
   autoload :Diagnostics,      'solargraph/diagnostics'
-  autoload :BasicTypeMethods, 'solargraph/basic_type_methods'
-  autoload :BasicType,        'solargraph/basic_type'
   autoload :ComplexType,      'solargraph/complex_type'
+  autoload :Bundle,           'solargraph/bundle'
 
   YARDOC_PATH = File.join(File.realpath(File.dirname(__FILE__)), '..', 'yardoc')
   YARD_EXTENSION_FILE = File.join(File.realpath(File.dirname(__FILE__)), 'yard-solargraph.rb')

data/lib/solargraph/api_map.rb

@@ -1,6 +1,5 @@
 require 'rubygems'
 require 'set'
-require 'time'
 
 module Solargraph
   # An aggregate provider for information about workspaces, sources, gems, and
@@ -12,132 +11,147 @@ module Solargraph
     autoload :Store,        'solargraph/api_map/store'
 
     include Solargraph::ApiMap::SourceToYard
-    include CoreFills
-
-    # The workspace to analyze and process.
-    #
-    # @return [Solargraph::Workspace]
-    attr_reader :workspace
 
     # Get a LiveMap associated with the current workspace.
     #
     # @return [Solargraph::LiveMap]
     attr_reader :live_map
 
-    # @param workspace [Solargraph::Workspace]
-    def initialize workspace = Solargraph::Workspace.new(nil)
-      @workspace = workspace
-      require_extensions
-      @virtual_source = nil
-      @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))
-    end
-
-    # @return [Array<Solargraph::Pin::Base>]
-    def pins
-      store.pins
-    end
-
     # @return [Array<String>]
-    def domains
-      @domains ||= []
-    end
+    attr_reader :unresolved_requires
 
-    # An array of required paths in the workspace.
+    # @param pins [Array<Solargraph::Pin::Base>]
+    # @param yard_map [YardMap]
+    # def initialize workspace = Solargraph::Workspace.new(nil)
+    def initialize pins: []
+      # @todo Extensions don't work yet
+      # require_extensions
+      @source_map_hash = {}
+      @cache = Cache.new
+      @mutex = Mutex.new
+      index pins
+    end
+
+    # @param pins [Array<Pin::Base>]
+    # @return [self]
+    def index pins
+      @mutex.synchronize {
+        @source_map_hash.clear
+        @cache.clear
+        @store = Store.new(pins + YardMap.new.pins)
+        @unresolved_requires = []
+      }
+      self
+    end
+
+    # @param source [Source]
+    # @return [self]
+    def map source
+      catalog Bundle.new(sources: [source])
+      self
+    end
+
+    # Catalog a workspace. Additional sources that need to be mapped can be
+    # included in an optional array.
     #
-    # @return [Array<String>]
-    def required
-      result = []
-      @sources.each do |s|
-        result.concat s.required.map(&:name)
+    # @param bundle [Bundle]
+    # @return [self]
+    def catalog bundle
+      # @todo This can be more efficient. We don't need to remap sources that
+      #   are already here.
+      # all_sources = (workspace.sources + others).uniq
+      new_map_hash = {}
+      unmerged = false
+      bundle.sources.each do |source|
+        if source_map_hash.has_key?(source.filename)
+          if source_map_hash[source.filename].code == source.code
+            new_map_hash[source.filename] = source_map_hash[source.filename]
+          else
+            map = Solargraph::SourceMap.map(source)
+            if source_map_hash[source.filename].try_merge!(map)
+              new_map_hash[source.filename] = source_map_hash[source.filename]
+            else
+              new_map_hash[source.filename] = map
+              unmerged = true
+            end
+          end
+        else
+          map = Solargraph::SourceMap.map(source)
+          new_map_hash[source.filename] = map
+          unmerged = true
+        end
       end
-      result.concat workspace.config.required
-      result.uniq
-    end
-
-    # Declare a virtual source that will be included in the map regardless of
-    # whether it's in the workspace.
-    #
-    # If the source is in the workspace, virtualizing it has no effect. Only
-    # one source can be virtualized at a time.
-    #
-    # @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
-      domains.concat source.domains unless source.nil?
-      domains.uniq!
-      if workspace.has_source?(source)
-        @sources = workspace.sources
-        @virtual_source = nil
-      else
-        @virtual_source = source
-        @sources = workspace.sources
-        unless @virtual_source.nil?
-          @sources.push @virtual_source
-          process_virtual
+      return self unless unmerged
+      pins = []
+      reqs = []
+      # @param map [SourceMap]
+      new_map_hash.values.each do |map|
+        pins.concat map.pins
+        reqs.concat map.requires.map(&:name)
+      end
+      reqs.concat bundle.required
+      unless bundle.load_paths.empty?
+        reqs.delete_if do |r|
+          result = false
+          bundle.load_paths.each do |l|
+            if new_map_hash.keys.include?(File.join(l, "#{r}.rb"))
+              result = true
+              break
+            end
+          end
+          result
         end
       end
-      source
+      bundle.yard_map.change(reqs)
+      new_store = Store.new(pins + bundle.yard_map.pins)
+      @mutex.synchronize {
+        @cache.clear
+        @source_map_hash = new_map_hash
+        @store = new_store
+        @unresolved_requires = bundle.yard_map.unresolved_requires
+      }
+      self
     end
 
-    # 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
+    # @param position [Position]
+    # @return [Source::Cursor]
+    def cursor_at filename, position
+      raise "File not found: #{filename}" unless source_map_hash.has_key?(filename)
+      source_map_hash[filename].cursor_at(position)
     end
 
-    # Refresh the ApiMap. This method checks for pending changes before
-    # performing the refresh unless the `force` parameter is true.
+    # Get a clip by filename and position.
     #
-    # @param force [Boolean] Perform a refresh even if the map is not "stale."
-    # @return [Boolean] True if a refresh was performed.
-    def refresh force = false
-      return false unless force or changed?
-      if force
-        refresh_store_and_maps
-      else
-        update_store_and_maps
-      end
-      true
+    # @param filename [String]
+    # @param position [Position]
+    # @return [SourceMap::Clip]
+    def clip_at filename, position
+      SourceMap::Clip.new(self, cursor_at(filename, position))
     end
 
-    # True if a workspace file has been created, modified, or deleted since
-    # the last time the map was processed.
+    # Create an ApiMap with a workspace in the specified directory.
     #
-    # @return [Boolean]
-    def changed?
-      return true if current_workspace_sources.length != workspace.sources.length
-      return true if @stime.nil?
-      return true if workspace.stime > @stime
-      return true if !@virtual_source.nil? and @virtual_source.stime > @stime
-      false
+    # @param directory [String]
+    # @return [ApiMap]
+    def self.load directory
+      # @todo How should this work?
+      api_map = self.new #(Solargraph::Workspace.new(directory))
+      workspace = Solargraph::Workspace.new(directory)
+      api_map.catalog Bundle.new(sources: workspace.sources)
+      api_map
+    end
+
+    # @return [Array<Solargraph::Pin::Base>]
+    def pins
+      store.pins
     end
 
     # An array of suggestions based on Ruby keywords (`if`, `end`, etc.).
     #
     # @return [Array<Solargraph::Pin::Keyword>]
     def self.keywords
-      @keywords ||= KEYWORDS.map{ |s|
+      @keywords ||= CoreFills::KEYWORDS.map{ |s|
         Pin::Keyword.new(s)
       }.freeze
     end
@@ -190,34 +204,26 @@ module Solargraph
     # Get a fully qualified namespace name. This method will start the search
     # in the specified context until it finds a match for the name.
     #
-    # @param namespace [String] The namespace to match
+    # @param namespace [String, nil] The namespace to match
     # @param context [String] The context to search
     # @return [String]
     def qualify namespace, context = ''
       # @todo The return for self might work better elsewhere
+      return nil if namespace.nil?
       return qualify(context) if namespace == 'self'
       cached = cache.get_qualified_namespace(namespace, context)
       return cached.clone unless cached.nil?
-      result = inner_qualify(namespace, context, [])
+      # result = inner_qualify(namespace, context, [])
+      # result = result[2..-1] if !result.nil? && result.start_with?('::')
+      if namespace.start_with?('::')
+        result = inner_qualify(namespace[2..-1], '', [])
+      else
+        result = inner_qualify(namespace, context, [])
+      end
       cache.set_qualified_namespace(namespace, context, result)
       result
     end
 
-    def fragment_at(location)
-      @sources.each do |source|
-        return source.fragment_at(location.range.start.line, location.range.start.column) if source.filename == location.filename
-      end
-      nil
-    end
-
-    # @deprecated Use #qualify instead
-    # @param namespace [String]
-    # @param context [String]
-    # @return [String]
-    def find_fully_qualified_namespace namespace, context = ''
-      qualify namespace, context
-    end
-
     # Get an array of instance variable pins defined in specified namespace
     # and scope.
     #
@@ -225,7 +231,14 @@ module Solargraph
     # @param scope [Symbol] :instance or :class
     # @return [Array<Solargraph::Pin::InstanceVariable>]
     def get_instance_variable_pins(namespace, scope = :instance)
-      store.get_instance_variables(namespace, scope)
+      result = []
+      result.concat store.get_instance_variables(namespace, scope)
+      sc = qualify(store.get_superclass(namespace), namespace)
+      until sc.nil?
+        result.concat store.get_instance_variables(sc, scope)
+        sc = qualify(store.get_superclass(sc), sc)
+      end
+      result
     end
 
     # Get an array of class variable pins for a namespace.
@@ -241,21 +254,10 @@ module Solargraph
       store.get_symbols
     end
 
-    # @todo Make this better
-    def get_source filename
-      @sources.each do |s|
-        return s if s.filename == filename
-      end
-      nil
-    end
-
     # @return [Array<Solargraph::Pin::GlobalVariable>]
     def get_global_variable_pins
-      globals = []
-      @sources.each do |s|
-        globals.concat s.global_variable_pins
-      end
-      globals
+      # @todo Slow version
+      pins.select{|p| p.kind == Pin::GLOBAL_VARIABLE}
     end
 
     # Get an array of methods available in a particular context.
@@ -271,21 +273,22 @@ module Solargraph
       result = []
       skip = []
       if fqns == ''
-        domains.each do |domain|
-          type = ComplexType.parse(domain).first
-          result.concat inner_get_methods(type.name, type.scope, [:public], deep, skip)
-        end
+        # @todo Implement domains
+        # domains.each do |domain|
+        #   type = ComplexType.parse(domain).first
+        #   result.concat inner_get_methods(type.name, type.scope, [:public], deep, skip)
+        # end
         result.concat inner_get_methods(fqns, :class, visibility, deep, skip)
         result.concat inner_get_methods(fqns, :instance, visibility, deep, skip)
         result.concat inner_get_methods('Kernel', :instance, visibility, deep, skip)
       else
         result.concat inner_get_methods(fqns, scope, visibility, deep, skip)
       end
-      live = live_map.get_methods(fqns, '', scope.to_s, visibility.include?(:private))
-      unless live.empty?
-        exist = result.map(&:name)
-        result.concat live.reject{|p| exist.include?(p.name)}
-      end
+      # live = live_map.get_methods(fqns, '', scope.to_s, visibility.include?(:private))
+      # unless live.empty?
+      #   exist = result.map(&:name)
+      #   result.concat live.reject{|p| exist.include?(p.name)}
+      # end
       cache.set_methods(fqns, scope, visibility, deep, result)
       result
     end
@@ -296,21 +299,17 @@ module Solargraph
     # @param context [String]
     # @return [Array<Solargraph::Pin::Base>]
     def get_complex_type_methods type, context = '', internal = false
-      return [] if type.undefined? or type.void?
+      return [] if type.undefined? || type.void?
       result = []
       if type.duck_type?
         type.select(&:duck_type?).each do |t|
           result.push Pin::DuckMethod.new(nil, t.tag[1..-1])
         end
       else
-        unless type.nil? or type.name == 'void'
+        unless type.nil? || type.name == 'void'
           namespace = qualify(type.namespace, context)
-          if ['Class', 'Module'].include?(namespace) and !type.subtypes.empty?
-            subtype = qualify(type.subtypes.first.name, context)
-            result.concat get_methods(subtype, scope: :class)
-          end
           visibility = [:public]
-          if namespace == context or super_and_sub?(namespace, context)
+          if namespace == context || super_and_sub?(namespace, context)
             visibility.push :protected
             visibility.push :private if internal
           end
@@ -333,9 +332,9 @@ module Solargraph
     # @param scope [Symbol] :instance or :class
     # @return [Array<Solargraph::Pin::Base>]
     def get_method_stack fqns, name, scope: :instance
-      # @todo Caches don't work on this query
+      # @todo This cache is still causing problems.
       # cached = cache.get_method_stack(fqns, name, scope)
-      # return cached.clone unless cached.nil?
+      # return cached 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
@@ -343,19 +342,29 @@ module Solargraph
 
     # Get an array of all suggestions that match the specified path.
     #
+    # @deprecated Use #get_path_pins instead.
+    #
     # @param path [String] The path to find
     # @return [Array<Solargraph::Pin::Base>]
     def get_path_suggestions path
       return [] if path.nil?
       result = []
       result.concat store.get_path_pins(path)
-      if result.empty?
-        lp = live_map.get_path_pin(path)
-        result.push lp unless lp.nil?
-      end
+      # if result.empty?
+      #   lp = live_map.get_path_pin(path)
+      #   result.push lp unless lp.nil?
+      # end
       result
     end
 
+    # Get an array of pins that match the specified path.
+    #
+    # @param path [String]
+    # @return [Array<Pin::Base>]
+    def get_path_pins path
+      get_path_suggestions(path)
+    end
+
     # Get a list of documented paths that match the query.
     #
     # @example
@@ -364,11 +373,10 @@ module Solargraph
     # @param query [String] The text to match
     # @return [Array<String>]
     def search query
-      rake_yard(store) if @yard_stale
-      @yard_stale = false
+      rake_yard(store)
       found = []
       code_object_paths.each do |k|
-        if found.empty? or (query.include?('.') or query.include?('#')) or !(k.include?('.') or k.include?('#'))
+        if found.empty? || (query.include?('.') || query.include?('#')) || !(k.include?('.') || k.include?('#'))
           found.push k if k.downcase.include?(query.downcase)
         end
       end
@@ -383,8 +391,7 @@ module Solargraph
     # @param path [String] The path to find
     # @return [Array<YARD::CodeObject::Base>]
     def document path
-      rake_yard(store) if @yard_stale
-      @yard_stale = false
+      rake_yard(store)
       docs = []
       docs.push code_object_at(path) unless code_object_at(path).nil?
       docs
@@ -396,74 +403,68 @@ module Solargraph
     # @return [Array<Pin::Base>]
     def query_symbols query
       result = []
-      @sources.each do |s|
+      source_map_hash.values.each do |s|
         result.concat s.query_symbols(query)
       end
       result
     end
 
-    # @param location [Solargraph::Source::Location]
+    # @param location [Solargraph::Location]
     # @return [Solargraph::Pin::Base]
     def locate_pin location
-      @sources.each do |source|
-        pin = source.locate_pin(location)
-        return pin unless pin.nil?
-      end
-      nil
+      return nil if location.nil? || !source_map_hash.has_key?(location.filename)
+      source_map_hash[location.filename].locate_pin(location)
     end
 
-    # @return [Array<String>]
-    def unresolved_requires
-      yard_map.unresolved_requires
+    # @raise [FileNotFoundError] if the cursor's file is not in the ApiMap
+    # @param cursor [Source::Cursor]
+    # @return [SourceMap::Clip]
+    def clip cursor
+      raise FileNotFoundError, "ApiMap did not catalog #{cursor.filename}" unless source_map_hash.has_key?(cursor.filename)
+      SourceMap::Clip.new(self, cursor)
     end
 
-    private
-
-    # @return [ApiMap::Store]
-    def store
-      @store ||= ApiMap::Store.new(@sources, yard_map.pins)
+    # Get an array of document symbols from a file.
+    #
+    # @param filename [String]
+    # @return [Array<Pin::Symbol>]
+    def document_symbols filename
+      return [] unless source_map_hash.has_key?(filename) # @todo Raise error?
+      source_map_hash[filename].document_symbols
     end
 
-    # @return [void]
-    def refresh_store_and_maps
-      @yard_stale = true
-      @live_map = Solargraph::LiveMap.new(self)
-      store.update_yard(yard_map.pins) if yard_map.change(required)
-      cache.clear
-      @stime = Time.now
+    # Get a source map by filename.
+    #
+    # @param filename [String]
+    # @return [SourceMap]
+    def source_map filename
+      raise FileNotFoundError, "Source map for `#{filename}` not found" unless source_map_hash.has_key?(filename)
+      source_map_hash[filename]
     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
+    private
 
-    # @return [void]
-    def process_virtual
-      map_source @virtual_source unless @virtual_source.nil?
-      if yard_map.change(required)
-        store.update_yard(yard_map.pins)
-      end
-      cache.clear
+    # A hash of source maps with filename keys.
+    #
+    # @return [Hash{String => SourceMap}]
+    def source_map_hash
+      @mutex.synchronize {
+        @source_map_hash
+      }
     end
 
-    # @param source [Solargraph::Source]
-    # @return [void]
-    def map_source source
-      store.update source
-      path_macros.merge! source.path_macros
+    # @return [ApiMap::Store]
+    def store
+      @mutex.synchronize {
+        @store
+      }
     end
 
     # @return [Solargraph::ApiMap::Cache]
     def cache
-      @cache ||= Cache.new
+      @mutex.synchronize {
+        @cache
+      }
     end
 
     # @param fqns [String] A fully qualified namespace
@@ -471,34 +472,41 @@ module Solargraph
     # @param visibility [Array<Symbol>] :public, :protected, and/or :private
     # @param deep [Boolean]
     # @param skip [Array<String>]
+    # @param no_core [Boolean] Skip core classes if true
     # @return [Array<Pin::Base>]
-    def inner_get_methods fqns, scope, visibility, deep, skip
+    def inner_get_methods fqns, scope, visibility, deep, skip, no_core = false
+      return [] if no_core && fqns =~ /^(Object|BasicObject|Class|Module|Kernel)$/
       reqstr = "#{fqns}|#{scope}|#{visibility.sort}|#{deep}"
       return [] if skip.include?(reqstr)
       skip.push reqstr
       result = []
-      result.concat store.get_attrs(fqns, scope)
       result.concat store.get_methods(fqns, scope: scope, visibility: visibility)
       if deep
         sc = store.get_superclass(fqns)
         unless sc.nil?
-          fqsc = qualify(sc, fqns)
-          result.concat inner_get_methods(fqsc, scope, visibility, true, skip) unless fqsc.nil?
+          fqsc = qualify(sc, fqns.split('::')[0..-2].join('::'))
+          result.concat inner_get_methods(fqsc, scope, visibility, true, skip, true) unless fqsc.nil?
         end
         if scope == :instance
-          store.get_includes(fqns).each do |im|
+          store.get_includes(fqns).reverse.each do |im|
             fqim = qualify(im, fqns)
-            result.concat inner_get_methods(fqim, scope, visibility, deep, skip) unless fqim.nil?
+            result.concat inner_get_methods(fqim, scope, visibility, deep, skip, true) unless fqim.nil?
           end
-          result.concat inner_get_methods('Object', :instance, [:public], deep, skip) unless fqns == 'Object'
+          result.concat inner_get_methods('Object', :instance, [:public], deep, skip, no_core)
         else
-          store.get_extends(fqns).each do |em|
+          store.get_extends(fqns).reverse.each do |em|
             fqem = qualify(em, fqns)
-            result.concat inner_get_methods(fqem, :instance, visibility, deep, skip) unless fqem.nil?
+            result.concat inner_get_methods(fqem, :instance, visibility, deep, skip, true) unless fqem.nil?
           end
-          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
+          unless no_core || fqns.empty?
+            type = get_namespace_type(fqns)
+            result.concat inner_get_methods('Class', :instance, visibility, deep, skip, no_core) if type == :class
+            result.concat inner_get_methods('Module', :instance,visibility, deep, skip, no_core)
+          end
+        end
+        store.domains(fqns).each do |d|
+          dt = ComplexType.parse(d)
+          result.concat inner_get_methods(dt.namespace, dt.scope, [:public], deep, skip)
         end
       end
       result
@@ -517,7 +525,7 @@ module Solargraph
         fqis = qualify(is, fqns)
         result.concat inner_get_constants(fqis, [:public], skip) unless fqis.nil?
       end
-      result.concat live_map.get_constants(fqns)
+      # result.concat live_map.get_constants(fqns)
       result
     end
 
@@ -538,11 +546,6 @@ module Solargraph
       @path_macros ||= {}
     end
 
-    # @return [Array<Solargraph::Source>]
-    def current_workspace_sources
-      @sources - [@virtual_source]
-    end
-
     # @param name [String]
     # @param root [String]
     # @param skip [Array<String>]
@@ -571,7 +574,7 @@ module Solargraph
           return name if store.namespace_exists?(name)
         end
       end
-      live_map.get_fqns(name, root)
+      # live_map.get_fqns(name, root)
     end
 
     # Get the namespace's type (Class or Module).
@@ -585,13 +588,6 @@ module Solargraph
       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
-
     # Sort an array of pins to put nil or undefined variables last.
     #
     # @param pins [Array<Solargraph::Pin::Base>]
@@ -600,7 +596,7 @@ module Solargraph
       result = []
       nil_pins = []
       pins.each do |pin|
-        if pin.variable? and pin.nil_assignment?
+        if pin.variable? && pin.nil_assignment?
           nil_pins.push pin
         else
           result.push pin
@@ -609,11 +605,17 @@ module Solargraph
       result + nil_pins
     end
 
+    # Check if a class is a superclass of another class.
+    #
+    # @param sup [String] The superclass
+    # @param sub [String] The subclass
+    # @return [Boolean]
     def super_and_sub?(sup, sub)
-      cls = store.get_superclass(sub)
+      fqsup = qualify(sup)
+      cls = qualify(store.get_superclass(sub), sub)
       until cls.nil?
-        return true if cls == sup
-        cls = store.get_superclass(cls)
+        return true if cls == fqsup
+        cls = qualify(store.get_superclass(cls), cls)
       end
       false
     end