cosmicgraph 0.49.0

data/lib/solargraph/rbs_map.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'rbs'
+require 'set'
+
+module Solargraph
+  class RbsMap
+    autoload :Conversions, 'solargraph/rbs_map/conversions'
+    autoload :CoreMap,     'solargraph/rbs_map/core_map'
+    autoload :CoreFills,   'solargraph/rbs_map/core_fills'
+    autoload :CoreSigns,   'solargraph/rbs_map/core_signs'
+    autoload :StdlibMap,   'solargraph/rbs_map/stdlib_map'
+
+    include Conversions
+
+    # @type [Hash{String => RbsMap}]
+    @@rbs_maps_hash = {}
+
+    attr_reader :library
+
+    # @param library [String]
+    def initialize library
+      @library = library
+      loader = RBS::EnvironmentLoader.new(core_root: nil, repository: repository)
+      add_library loader, library
+      return unless resolved?
+      environment = RBS::Environment.from_loader(loader).resolve_type_names
+      environment.declarations.each { |decl| convert_decl_to_pin(decl, Solargraph::Pin::ROOT_PIN) }
+    end
+
+    def path_pin path
+      pins.find { |p| p.path == path }
+    end
+
+    def path_pins path
+      pins.select { |p| p.path == path }
+    end
+
+    def resolved?
+      @resolved
+    end
+
+    # @param library [String]
+    # @return [RbsMap]
+    def self.load library
+      @@rbs_maps_hash[library] ||= RbsMap.new(library)
+    end
+
+    def repository
+      @repository ||= RBS::Repository.new(no_stdlib: true)
+    end
+
+    private
+
+    # @param loader [RBS::EnvironmentLoader]
+    # @param library [String]
+    # @return [Boolean] true if adding the library succeeded
+    def add_library loader, library
+      @resolved = if loader.has_library?(library: library, version: nil)
+        loader.add library: library
+        Solargraph.logger.info "#{short_name} successfully loaded library #{library}"
+        true
+      else
+        Solargraph.logger.info "#{short_name} failed to load library #{library}"
+        false
+      end
+    end
+
+    def short_name
+      self.class.name.split('::').last
+    end
+  end
+end

data/lib/solargraph/server_methods.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'socket'
+
+module Solargraph
+  module ServerMethods
+    # @return [Integer]
+    def available_port
+      socket = Socket.new(:INET, :STREAM, 0)
+      socket.bind(Addrinfo.tcp("127.0.0.1", 0))
+      port = socket.local_address.ip_port
+      socket.close
+      port
+    end
+  end
+end

data/lib/solargraph/shell.rb

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+require 'thor'
+
+module Solargraph
+  class Shell < Thor
+    include Solargraph::ServerMethods
+
+    map %w[--version -v] => :version
+
+    desc "--version, -v", "Print the version"
+    def version
+      puts Solargraph::VERSION
+    end
+
+    desc 'socket', 'Run a Solargraph socket server'
+    option :host, type: :string, aliases: :h, desc: 'The server host', default: '127.0.0.1'
+    option :port, type: :numeric, aliases: :p, desc: 'The server port', default: 7658
+    def socket
+      require 'backport'
+      port = options[:port]
+      port = available_port if port.zero?
+      Backport.run do
+        Signal.trap("INT") do
+          Backport.stop
+        end
+        Signal.trap("TERM") do
+          Backport.stop
+        end
+        Backport.prepare_tcp_server host: options[:host], port: port, adapter: Solargraph::LanguageServer::Transport::Adapter
+        STDERR.puts "Solargraph is listening PORT=#{port} PID=#{Process.pid}"
+      end
+    end
+
+    desc 'stdio', 'Run a Solargraph stdio server'
+    def stdio
+      require 'backport'
+      Backport.run do
+        Signal.trap("INT") do
+          Backport.stop
+        end
+        Signal.trap("TERM") do
+          Backport.stop
+        end
+        Backport.prepare_stdio_server adapter: Solargraph::LanguageServer::Transport::Adapter
+        STDERR.puts "Solargraph is listening on stdio PID=#{Process.pid}"
+      end
+    end
+
+    desc 'config [DIRECTORY]', 'Create or overwrite a default configuration file'
+    option :extensions, type: :boolean, aliases: :e, desc: 'Add installed extensions', default: true
+    def config(directory = '.')
+      matches = []
+      if options[:extensions]
+        Gem::Specification.each do |g|
+          if g.name.match(/^solargraph\-[A-Za-z0-9_\-]*?\-ext/)
+            require g.name
+            matches.push g.name
+          end
+        end
+      end
+      conf = Solargraph::Workspace::Config.new.raw_data
+      unless matches.empty?
+        matches.each do |m|
+          conf['extensions'].push m
+        end
+      end
+      File.open(File.join(directory, '.solargraph.yml'), 'w') do |file|
+        file.puts conf.to_yaml
+      end
+      STDOUT.puts "Configuration file initialized."
+    end
+
+    desc 'download-core [VERSION]', 'Download core documentation [deprecated]'
+    long_desc %(
+      The `download-core` command is deprecated. Current versions of Solargraph
+      use RBS for core and stdlib documentation.
+    )
+    # @deprecated
+    def download_core _version = nil
+      puts 'The `download-core` command is deprecated.'
+      puts 'Current versions of Solargraph use RBS for core and stdlib documentation.'
+    end
+
+    desc 'list-cores', 'List the local documentation versions [deprecated]'
+    long_desc %(
+      The `list-cores` command is deprecated. Current versions of Solargraph use
+      RBS for core and stdlib documentation.
+    )
+    # @deprecated
+    def list_cores
+      puts 'The `list-cores` command is deprecated.'
+      puts 'Current versions of Solargraph use RBS for core and stdlib documentation.'
+    end
+
+    desc 'available-cores', 'List available documentation versions [deprecated]'
+    long_desc %(
+      The `available-cores` command is deprecated. Current versions of Solargraph
+      use RBS for core and stdlib documentation.
+    )
+    # @deprecated
+    def available_cores
+      puts 'The `available-cores` command is deprecated.'
+      puts 'Current versions of Solargraph use RBS for core and stdlib documentation.'
+    end
+
+    desc 'clear', 'Delete all cached documentation'
+    long_desc %(
+      This command will delete all core and gem documentation from the cache.
+    )
+    # @deprecated
+    def clear
+      puts "Deleting the cached documentation"
+      Solargraph::Cache.clear
+    end
+    map 'clear-cache' => :clear
+    map 'clear-cores' => :clear
+
+    desc 'uncache GEM [...GEM]', "Delete cached gem documentation"
+    def uncache *gems
+      raise ArgumentError, 'No gems specified.' if gems.empty?
+      gems.each do |gem|
+        Dir[File.join(Solargraph::YardMap::CoreDocs.cache_dir, 'gems', "#{gem}-*")].each do |dir|
+          puts "Deleting cache: #{dir}"
+          FileUtils.remove_entry_secure dir
+        end
+      end
+    end
+
+    desc 'reporters', 'Get a list of diagnostics reporters'
+    def reporters
+      puts Solargraph::Diagnostics.reporters
+    end
+
+    desc 'typecheck [FILE(s)]', 'Run the type checker'
+    long_desc %(
+      Perform type checking on one or more files in a workspace. Check the
+      entire workspace if no files are specified.
+
+      Type checking levels are normal, typed, strict, and strong.
+    )
+    option :level, type: :string, aliases: [:mode, :m, :l], desc: 'Type checking level', default: 'normal'
+    option :directory, type: :string, aliases: :d, desc: 'The workspace directory', default: '.'
+    def typecheck *files
+      directory = File.realpath(options[:directory])
+      api_map = Solargraph::ApiMap.load(directory)
+      if files.empty?
+        files = api_map.source_maps.map(&:filename)
+      else
+        files.map! { |file| File.realpath(file) }
+      end
+      probcount = 0
+      filecount = 0
+      files.each do |file|
+        checker = TypeChecker.new(file, api_map: api_map, level: options[:level].to_sym)
+        problems = checker.problems
+        next if problems.empty?
+        problems.sort! { |a, b| a.location.range.start.line <=> b.location.range.start.line }
+        puts problems.map { |prob| "#{prob.location.filename}:#{prob.location.range.start.line + 1} - #{prob.message}" }.join("\n")
+        filecount += 1
+        probcount += problems.length
+      end
+      puts "#{probcount} problem#{probcount != 1 ? 's' : ''} found#{files.length != 1 ? " in #{filecount} of #{files.length} files" : ''}."
+      exit 1 if probcount > 0
+    end
+
+    desc 'scan', 'Test the workspace for problems'
+    long_desc %(
+      A scan loads the entire workspace to make sure that the ASTs and
+      maps do not raise errors during analysis. It does not perform any type
+      checking or validation; it only confirms that the analysis itself is
+      error-free.
+    )
+    option :directory, type: :string, aliases: :d, desc: 'The workspace directory', default: '.'
+    option :verbose, type: :boolean, aliases: :v, desc: 'Verbose output', default: false
+    def scan
+      require 'benchmark'
+      directory = File.realpath(options[:directory])
+      api_map = nil
+      time = Benchmark.measure {
+        api_map = Solargraph::ApiMap.load(directory)
+        api_map.pins.each do |pin|
+          begin
+            puts pin_description(pin) if options[:verbose]
+            pin.typify api_map
+            pin.probe api_map
+          rescue StandardError => e
+            STDERR.puts "Error testing #{pin_description(pin)} #{pin.location ? "at #{pin.location.filename}:#{pin.location.range.start.line + 1}" : ''}"
+            STDERR.puts "[#{e.class}]: #{e.message}"
+            STDERR.puts e.backtrace.join("\n")
+            exit 1
+          end
+        end
+      }
+      puts "Scanned #{directory} (#{api_map.pins.length} pins) in #{time.real} seconds."
+    end
+
+    desc 'bundle', 'Generate documentation for bundled gems [deprecated]'
+    long_desc %(
+      The `bundle` command is deprecated. Solargraph currently uses RBS instead.
+    )
+    option :directory, type: :string, aliases: :d, desc: 'The workspace directory', default: '.'
+    option :rebuild, type: :boolean, aliases: :r, desc: 'Rebuild existing documentation', default: false
+    def bundle
+      puts 'The `bundle` command is deprecated. Solargraph currently uses RBS instead.'
+    end
+
+    desc 'rdoc GEM [VERSION]', 'Use RDoc to cache documentation [deprecated]'
+    long_desc %(
+      The `rdoc` command is deprecated. Solargraph currently uses RBS instead.
+    )
+    def rdoc _gem, _version = '>= 0'
+      puts 'The `rdoc` command is deprecated. Solargraph currently uses RBS instead.'
+    end
+
+    private
+
+    # @param pin [Solargraph::Pin::Base]
+    # @return [String]
+    def pin_description pin
+      desc = if pin.path.nil? || pin.path.empty?
+        if pin.closure
+          "#{pin.closure.path} | #{pin.name}"
+        else
+          "#{pin.context.namespace} | #{pin.name}"
+        end
+      else
+        pin.path
+      end
+      desc += " (#{pin.location.filename} #{pin.location.range.start.line})" if pin.location
+      desc
+    end
+  end
+end

data/lib/solargraph/source/chain/block_variable.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class Source
+    class Chain
+      class BlockVariable < Link
+        def resolve api_map, name_pin, locals
+          [Pin::ProxyType.anonymous(ComplexType.try_parse('Proc'))]
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/source/chain/call.rb

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class Source
+    class Chain
+      class Call < Link
+        # @return [String]
+        attr_reader :word
+
+        # @return [Array<Chain>]
+        attr_reader :arguments
+
+        # @param word [String]
+        # @param arguments [Array<Chain>]
+        # @param with_block [Boolean] True if the chain is inside a block
+        # @param head [Boolean] True if the call is the start of its chain
+        def initialize word, arguments = [], with_block = false
+          @word = word
+          @arguments = arguments
+          @with_block = with_block
+        end
+
+        def with_block?
+          @with_block
+        end
+
+        # @param api_map [ApiMap]
+        # @param name_pin [Pin::Base]
+        # @param locals [Array<Pin::Base>]
+        def resolve api_map, name_pin, locals
+          return super_pins(api_map, name_pin) if word == 'super'
+          found = if head?
+            locals.select { |p| p.name == word }
+          else
+            []
+          end
+          return inferred_pins(found, api_map, name_pin.context, locals) unless found.empty?
+          # @param [ComplexType::UniqueType]
+          pins = name_pin.binder.each_unique_type.flat_map do |context|
+            api_map.get_method_stack(context.namespace, word, scope: context.scope)
+          end
+          return [] if pins.empty?
+          inferred_pins(pins, api_map, name_pin.context, locals)
+        end
+
+        private
+
+        # @param pins [Array<Pin::Base>]
+        # @param api_map [ApiMap]
+        # @param context [ComplexType]
+        # @param locals [Pin::LocalVariable]
+        # @return [Array<Pin::Base>]
+        def inferred_pins pins, api_map, context, locals
+          result = pins.map do |p|
+            next p unless p.is_a?(Pin::Method)
+            overloads = p.signatures
+            # next p if overloads.empty?
+            type = ComplexType::UNDEFINED
+            overloads.each do |ol|
+              next unless arguments_match(arguments, ol)
+              # next if ol.parameters.last && ol.parameters.last.first.start_with?('&') && ol.parameters.last.last.nil? && !with_block?
+              match = true
+              arguments.each_with_index do |arg, idx|
+                param = ol.parameters[idx]
+                if param.nil?
+                  match = false unless ol.parameters.any?(&:restarg?)
+                  break
+                end
+                atype = arg.infer(api_map, Pin::ProxyType.anonymous(context), locals)
+                # @todo Weak type comparison
+                # unless atype.tag == param.return_type.tag || api_map.super_and_sub?(param.return_type.tag, atype.tag)
+                unless param.return_type.undefined? || atype.name == param.return_type.name || api_map.super_and_sub?(param.return_type.name, atype.name)
+                  match = false
+                  break
+                end
+              end
+              if match
+                type = extra_return_type(p.docstring, context)
+                break if type
+                type = with_params(ol.return_type.self_to(context.to_s), context).qualify(api_map, context.namespace) if ol.return_type.defined?
+                type ||= ComplexType::UNDEFINED
+              end
+              break if type.defined?
+            end
+            next p.proxy(type) if type.defined?
+            type = extra_return_type(p.docstring, context)
+            if type
+              next Solargraph::Pin::Method.new(
+                location: p.location,
+                closure: p.closure,
+                name: p.name,
+                comments: "@return [#{context.subtypes.first.to_s}]",
+                scope: p.scope,
+                visibility: p.visibility,
+                parameters: p.parameters,
+                node: p.node
+              )
+            end
+            if p.is_a?(Pin::Method) && !p.macros.empty?
+              result = process_macro(p, api_map, context, locals)
+              next result unless result.return_type.undefined?
+            elsif !p.directives.empty?
+              result = process_directive(p, api_map, context, locals)
+              next result unless result.return_type.undefined?
+            end
+            p
+          end
+          result.map do |pin|
+            if pin.path == 'Class#new' && context.tag != 'Class'
+              pin.proxy(ComplexType.try_parse(context.namespace))
+            else
+              next pin if pin.return_type.undefined?
+              selfy = pin.return_type.self_to(context.tag)
+              selfy == pin.return_type ? pin : pin.proxy(selfy)
+            end
+          end
+        end
+
+        # @param pin [Pin::Method]
+        # @param api_map [ApiMap]
+        # @param context [ComplexType]
+        # @param locals [Pin::Base]
+        # @return [Pin::Base]
+        def process_macro pin, api_map, context, locals
+          pin.macros.each do |macro|
+            result = inner_process_macro(pin, macro, api_map, context, locals)
+            return result unless result.return_type.undefined?
+          end
+          Pin::ProxyType.anonymous(ComplexType::UNDEFINED)
+        end
+
+        # @param pin [Pin::Method]
+        # @param api_map [ApiMap]
+        # @param context [ComplexType]
+        # @param locals [Pin::Base]
+        # @return [Pin::ProxyType]
+        def process_directive pin, api_map, context, locals
+          pin.directives.each do |dir|
+            macro = api_map.named_macro(dir.tag.name)
+            next if macro.nil?
+            result = inner_process_macro(pin, macro, api_map, context, locals)
+            return result unless result.return_type.undefined?
+          end
+          Pin::ProxyType.anonymous ComplexType::UNDEFINED
+        end
+
+        # @param pin [Pin]
+        # @param macro [YARD::Tags::MacroDirective]
+        # @param api_map [ApiMap]
+        # @param context [ComplexType]
+        # @param locals [Array<Pin::Base>]
+        # @return [Pin::ProxyType]
+        def inner_process_macro pin, macro, api_map, context, locals
+          vals = arguments.map{ |c| Pin::ProxyType.anonymous(c.infer(api_map, pin, locals)) }
+          txt = macro.tag.text.clone
+          if txt.empty? && macro.tag.name
+            named = api_map.named_macro(macro.tag.name)
+            txt = named.tag.text.clone if named
+          end
+          i = 1
+          vals.each do |v|
+            txt.gsub!(/\$#{i}/, v.context.namespace)
+            i += 1
+          end
+          docstring = Solargraph::Source.parse_docstring(txt).to_docstring
+          tag = docstring.tag(:return)
+          unless tag.nil? || tag.types.nil?
+            return Pin::ProxyType.anonymous(ComplexType.try_parse(*tag.types))
+          end
+          Pin::ProxyType.anonymous(ComplexType::UNDEFINED)
+        end
+
+        # @param docstring [YARD::Docstring]
+        # @param context [ComplexType]
+        # @return [ComplexType]
+        def extra_return_type docstring, context
+          if docstring.has_tag?(:return_single_parameter) #&& context.subtypes.one?
+            return context.subtypes.first || ComplexType::UNDEFINED
+          elsif docstring.has_tag?(:return_value_parameter) && context.value_types.one?
+            return context.value_types.first
+          end
+          nil
+        end
+
+        # @param arguments [Array<Chain>]
+        # @param signature [Pin::Signature]
+        # @return [Boolean]
+        def arguments_match arguments, signature
+          parameters = signature.parameters
+          argcount = arguments.length
+          parcount = parameters.length
+          parcount -= 1 if !parameters.empty? && parameters.last.block?
+          return false if signature.block? && !with_block?
+          return false if argcount < parcount && !(argcount == parcount - 1 && parameters.last.restarg?)
+          true
+        end
+
+        # @param api_map [ApiMap]
+        # @param name_pin [Pin::Base]
+        # @return [Array<Pin::Base>]
+        def super_pins api_map, name_pin
+          pins = api_map.get_method_stack(name_pin.namespace, name_pin.name, scope: name_pin.scope)
+          pins.reject{|p| p.path == name_pin.path}
+        end
+
+        # @param type [ComplexType]
+        # @param context [ComplexType]
+        def with_params type, context
+          return type unless type.to_s.include?('$')
+          ComplexType.try_parse(type.to_s.gsub('$', context.value_types.map(&:tag).join(', ')).gsub('<>', ''))
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/source/chain/class_variable.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class Source
+    class Chain
+      class ClassVariable < Link
+        def resolve api_map, name_pin, locals
+          api_map.get_class_variable_pins(name_pin.context.namespace).select{|p| p.name == word}
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/source/chain/constant.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class Source
+    class Chain
+      class Constant < Link
+        def initialize word
+          @word = word
+        end
+
+        def resolve api_map, name_pin, locals
+          return [Pin::ROOT_PIN] if word.empty?
+          if word.start_with?('::')
+            base = word[2..-1]
+            gates = ['']
+          else
+            base = word
+            gates = crawl_gates(name_pin)
+          end
+          parts = base.split('::')
+          gates.each do |gate|
+            type = deep_constant_type(gate, api_map)
+            # Use deep inference to resolve root 
+            parts[0..-2].each do |sym|
+              pins = api_map.get_constants('', type.namespace).select{ |pin| pin.name == sym }
+              type = first_pin_type(pins, api_map)
+              break if type.undefined?
+            end
+            next if type.undefined?
+            result = api_map.get_constants('', type.namespace).select { |pin| pin.name == parts.last }
+            return result unless result.empty?
+          end
+          []
+        end
+
+        private
+
+        def crawl_gates pin
+          clos = pin
+          until clos.nil?
+            if clos.is_a?(Pin::Namespace)
+              gates = clos.gates
+              gates.push('') if gates.empty?
+              return gates
+            end
+            clos = clos.closure
+          end
+          ['']
+        end
+
+        def first_pin_type(pins, api_map)
+          type = ComplexType::UNDEFINED
+          pins.each do |pin|
+            type = pin.typify(api_map)
+            break if type.defined?
+            type = pin.probe(api_map)
+            break if type.defined?
+          end
+          type
+        end
+
+        def deep_constant_type(gate, api_map)
+          type = ComplexType::ROOT
+          return type if gate == ''
+          gate.split('::').each do |word|
+            pins = api_map.get_constants('', type.namespace).select { |pin| pin.name == word }
+            type = first_pin_type(pins, api_map)
+            break if type.undefined?
+          end
+          type
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/source/chain/global_variable.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class Source
+    class Chain
+      class GlobalVariable < Link
+        def resolve api_map, name_pin, locals
+          api_map.get_global_variable_pins.select{|p| p.name == word}
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/source/chain/hash.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class Source
+    class Chain
+      class Hash < Literal
+        # @param type [String]
+        # @param splatted [Boolean]
+        def initialize type, splatted = false
+          super(type)
+          @splatted = splatted
+        end
+
+        def word
+          @word ||= "<#{@type}>"
+        end
+
+        def resolve api_map, name_pin, locals
+          [Pin::ProxyType.anonymous(@complex_type)]
+        end
+
+        def splatted?
+          @splatted
+        end
+      end
+    end
+  end
+end