solargraph 0.54.0 → 0.54.1

data/lib/solargraph/library.rb

@@ -27,11 +27,11 @@ module Solargraph
     def initialize workspace = Solargraph::Workspace.new, name = nil
       @workspace = workspace
       @name = name
-      @threads = []
       # @type [Integer, nil]
       @total = nil
       # @type [Source, nil]
       @current = nil
+      @sync_count = 0
     end
 
     def inspect
@@ -44,7 +44,7 @@ module Solargraph
     #
     # @return [Boolean]
     def synchronized?
-      !mutex.locked?
+      @sync_count < 2
     end
 
     # Attach a source to the library.
@@ -174,9 +174,9 @@ module Solargraph
     # @return [Array<Solargraph::Pin::Base>, nil]
     # @todo Take filename/position instead of filename/line/column
     def definitions_at filename, line, column
+      sync_catalog
       position = Position.new(line, column)
       cursor = Source::Cursor.new(read(filename), position)
-      sync_catalog
       if cursor.comment?
         source = read(filename)
         offset = Solargraph::Position.to_offset(source.code, Solargraph::Position.new(line, column))
@@ -190,7 +190,14 @@ module Solargraph
           []
         end
       else
-        mutex.synchronize { api_map.clip(cursor).define.map { |pin| pin.realize(api_map) } }
+        mutex.synchronize do
+          clip = api_map.clip(cursor)
+          if cursor.assign?
+            [Pin::ProxyType.new(name: cursor.word, return_type: clip.infer)]
+          else
+            clip.define.map { |pin| pin.realize(api_map) }
+          end
+        end
       end
     rescue FileNotFoundError => e
       handle_file_not_found(filename, e)
@@ -205,9 +212,9 @@ module Solargraph
     # @return [Array<Solargraph::Pin::Base>, nil]
     # @todo Take filename/position instead of filename/line/column
     def type_definitions_at filename, line, column
+      sync_catalog
       position = Position.new(line, column)
       cursor = Source::Cursor.new(read(filename), position)
-      sync_catalog
       mutex.synchronize { api_map.clip(cursor).types }
     rescue FileNotFoundError => e
       handle_file_not_found filename, e
@@ -222,9 +229,9 @@ module Solargraph
     # @return [Array<Solargraph::Pin::Base>]
     # @todo Take filename/position instead of filename/line/column
     def signatures_at filename, line, column
+      sync_catalog
       position = Position.new(line, column)
       cursor = Source::Cursor.new(read(filename), position)
-      sync_catalog
       mutex.synchronize { api_map.clip(cursor).signify }
     end
 
@@ -416,20 +423,7 @@ module Solargraph
     #
     # @return [void]
     def catalog
-      @threads.delete_if(&:stop?)
-      @threads.push(Thread.new do
-        sleep 0.05 if RUBY_PLATFORM =~ /mingw/
-        next unless @threads.last == Thread.current
-
-        mutex.synchronize do
-          logger.info "Cataloging #{workspace.directory.empty? ? 'generic workspace' : workspace.directory}"
-          api_map.catalog bench
-          logger.info "Catalog complete (#{api_map.source_maps.length} files, #{api_map.pins.length} pins)"
-          logger.info "#{api_map.uncached_gemspecs.length} uncached gemspecs"
-          cache_next_gemspec
-        end
-      end)
-      @threads.last.run if RUBY_PLATFORM =~ /mingw/
+      @sync_count += 1
     end
 
     # @return [Bench]
@@ -467,7 +461,6 @@ module Solargraph
     # @param source [Source]
     # @return [Boolean] True if the source was merged into the workspace.
     def merge source
-      Logging.logger.debug "Merging source: #{source.filename}"
       result = workspace.merge(source)
       maybe_map source
       result
@@ -489,7 +482,6 @@ module Solargraph
       if src
         Logging.logger.debug "Mapping #{src.filename}"
         source_map_hash[src.filename] = Solargraph::SourceMap.map(src)
-        find_external_requires(source_map_hash[src.filename])
         source_map_hash[src.filename]
       else
         false
@@ -500,7 +492,7 @@ module Solargraph
     def map!
       workspace.sources.each do |src|
         source_map_hash[src.filename] = Solargraph::SourceMap.map(src)
-        find_external_requires(source_map_hash[src.filename])
+        find_external_requires source_map_hash[src.filename]
       end
       self
     end
@@ -580,22 +572,10 @@ module Solargraph
       return unless source
       return unless @current == source || workspace.has_file?(source.filename)
       if source_map_hash.key?(source.filename)
-        return if source_map_hash[source.filename].code == source.code &&
-          source_map_hash[source.filename].source.synchronized? &&
-          source.synchronized?
-        if source.synchronized?
-          new_map = Solargraph::SourceMap.map(source)
-          unless source_map_hash[source.filename].try_merge!(new_map)
-            source_map_hash[source.filename] = new_map
-            find_external_requires(source_map_hash[source.filename])
-          end
-        else
-          # @todo Smelly instance variable access
-          source_map_hash[source.filename].instance_variable_set(:@source, source)
-        end
+        new_map = Solargraph::SourceMap.map(source)
+        source_map_hash[source.filename] = new_map
       else
         source_map_hash[source.filename] = Solargraph::SourceMap.map(source)
-        find_external_requires(source_map_hash[source.filename])
       end
     end
 
@@ -625,6 +605,7 @@ module Solargraph
       ensure
         end_cache_progress
         catalog
+        sync_catalog
       end
     end
 
@@ -666,8 +647,18 @@ module Solargraph
     end
 
     def sync_catalog
-      @threads.delete_if(&:stop?)
-              .last&.join
+      return if @sync_count == 0
+
+      mutex.synchronize do
+        logger.warn "CATALOG"
+        logger.info "Cataloging #{workspace.directory.empty? ? 'generic workspace' : workspace.directory}"
+        api_map.catalog bench
+        source_map_hash.values.each { |map| find_external_requires(map) }
+        logger.info "Catalog complete (#{api_map.source_maps.length} files, #{api_map.pins.length} pins)"
+        logger.info "#{api_map.uncached_gemspecs.length} uncached gemspecs"
+        cache_next_gemspec
+        @sync_count = 0
+      end
     end
   end
 end

data/lib/solargraph/location.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
 module Solargraph
-  # A section of text identified by its filename and range.
+  # A pointer to a section of source text identified by its filename
+  # and Range.
   #
   class Location
     # @return [String]
@@ -17,6 +18,11 @@ module Solargraph
       @range = range
     end
 
+    # @param location [self]
+    def contain? location
+      range.contain?(location.range.start) && range.contain?(location.range.ending) && filename == location.filename
+    end
+
     # @return [Hash]
     def to_hash
       {
@@ -25,6 +31,13 @@ module Solargraph
       }
     end
 
+    # @param node [Parser::AST::Node, nil]
+    def self.from_node(node)
+      return nil if node.nil? || node.loc.nil?
+      range = Range.from_node(node)
+      self.new(node.loc.expression.source_buffer.name, range)
+    end
+
     # @param other [BasicObject]
     def == other
       return false unless other.is_a?(Location)

data/lib/solargraph/parser/parser_gem/node_chainer.rb

@@ -89,15 +89,21 @@ module Solargraph
           elsif n.type == :const
             const = unpack_name(n)
             result.push Chain::Constant.new(const)
-          elsif [:lvar, :lvasgn].include?(n.type)
+          elsif [:lvasgn, :ivasgn, :gvasgn, :cvasgn].include?(n.type)
+            result.concat generate_links(n.children[1])
+          elsif n.type == :lvar
             result.push Chain::Call.new(n.children[0].to_s)
-          elsif [:ivar, :ivasgn].include?(n.type)
-            result.push Chain::InstanceVariable.new(n.children[0].to_s)
-          elsif [:cvar, :cvasgn].include?(n.type)
-            result.push Chain::ClassVariable.new(n.children[0].to_s)
-          elsif [:gvar, :gvasgn].include?(n.type)
-            result.push Chain::GlobalVariable.new(n.children[0].to_s)
+          elsif n.type == :ivar
+             result.push Chain::InstanceVariable.new(n.children[0].to_s)
+          elsif n.type == :cvar
+             result.push Chain::ClassVariable.new(n.children[0].to_s)
+          elsif n.type == :gvar
+             result.push Chain::GlobalVariable.new(n.children[0].to_s)
           elsif n.type == :or_asgn
+            # @todo: Need a new Link class here that evaluates the
+            #   existing variable type with the RHS, and generates a
+            #   union type of the LHS alone if never nil, or minus nil +
+            #   RHS if it is nilable.
             result.concat generate_links n.children[1]
           elsif [:class, :module, :def, :defs].include?(n.type)
             # @todo Undefined or what?

data/lib/solargraph/parser/parser_gem/node_methods.rb

@@ -311,7 +311,7 @@ module Solargraph
         #    statements in value positions.
         module DeepInference
           class << self
-            CONDITIONAL_ALL_BUT_FIRST = [:if, :unless, :or_asgn]
+            CONDITIONAL_ALL_BUT_FIRST = [:if, :unless]
             CONDITIONAL_ALL = [:or]
             ONLY_ONE_CHILD = [:return]
             FIRST_TWO_CHILDREN = [:rescue]

data/lib/solargraph/parser/parser_gem/node_processors/args_node.rb

@@ -6,22 +6,25 @@ module Solargraph
       module NodeProcessors
         class ArgsNode < Parser::NodeProcessor::Base
           def process
-            if node.type == :forward_args
-              forward
-            else
-              node.children.each do |u|
-                loc = get_node_location(u)
-                locals.push Solargraph::Pin::Parameter.new(
-                  location: loc,
-                  closure: region.closure,
-                  comments: comments_for(node),
-                  name: u.children[0].to_s,
-                  assignment: u.children[1],
-                  asgn_code: u.children[1] ? region.code_for(u.children[1]) : nil,
-                  presence: region.closure.location.range,
-                  decl: get_decl(u)
-                )
-                region.closure.parameters.push locals.last
+            callable = region.closure
+            if callable.is_a? Pin::Callable
+              if node.type == :forward_args
+                forward(callable)
+              else
+                node.children.each do |u|
+                  loc = get_node_location(u)
+                  locals.push Solargraph::Pin::Parameter.new(
+                                location: loc,
+                                closure: callable,
+                                comments: comments_for(node),
+                                name: u.children[0].to_s,
+                                assignment: u.children[1],
+                                asgn_code: u.children[1] ? region.code_for(u.children[1]) : nil,
+                                presence: callable.location.range,
+                                decl: get_decl(u)
+                              )
+                  callable.parameters.push locals.last
+                end
               end
             end
             process_children
@@ -29,16 +32,17 @@ module Solargraph
 
           private
 
+          # @param callable [Pin::Callable]
           # @return [void]
-          def forward
+          def forward(callable)
             loc = get_node_location(node)
             locals.push Solargraph::Pin::Parameter.new(
               location: loc,
-              closure: region.closure,
+              closure: callable,
               presence: region.closure.location.range,
               decl: get_decl(node)
             )
-            region.closure.parameters.push locals.last
+            callable.parameters.push locals.last
           end
 
           # @param node [AST::Node]

data/lib/solargraph/parser/parser_gem/node_processors/lvasgn_node.rb

@@ -8,8 +8,8 @@ module Solargraph
           include ParserGem::NodeMethods
 
           def process
-            here = get_node_start_position(node)
-            presence = Range.new(here, region.closure.location.range.ending)
+            # variable not visible until next statement
+            presence = Range.new(get_node_end_position(node), region.closure.location.range.ending)
             loc = get_node_location(node)
             locals.push Solargraph::Pin::LocalVariable.new(
               location: loc,

data/lib/solargraph/parser/parser_gem/node_processors/masgn_node.rb

@@ -30,11 +30,17 @@ module Solargraph
 
             lhs_arr.each_with_index do |lhs, i|
               location = get_node_location(lhs)
+              pin = if lhs.type == :lvasgn
+                      # lvasgn is a local variable
+                      locals.find { |l| l.location == location }
+                    else
+                      # e.g., ivasgn is an instance variable, etc
+                      pins.find { |iv| iv.location == location && iv.is_a?(Pin::BaseVariable) }
+                    end
               # @todo in line below, nothing in typechecking alerts
               #   when a non-existant method is called on 'l'
-              pin = locals.find { |l| l.location == location }
               if pin.nil?
-                Solargraph.logger.debug "Could not find pin in location #{location}"
+                Solargraph.logger.debug { "Could not find local for masgn= value in location #{location.inspect} in #{lhs_arr} - masgn = #{masgn}, lhs.type = #{lhs.type}" }
                 next
               end
               pin.mass_assignment = [mass_rhs, i]

data/lib/solargraph/parser/parser_gem/node_processors/send_node.rb

@@ -92,7 +92,7 @@ module Solargraph
                 pins.push method_pin
                 method_pin.parameters.push Pin::Parameter.new(name: 'value', decl: :arg, closure: pins.last)
                 if method_pin.return_type.defined?
-                  pins.last.docstring.add_tag YARD::Tags::Tag.new(:param, '', pins.last.return_type.to_s.split(', '), 'value')
+                  pins.last.docstring.add_tag YARD::Tags::Tag.new(:param, '', pins.last.return_type.items.map(&:rooted_tags), 'value')
                 end
               end
             end

data/lib/solargraph/parser.rb

@@ -9,15 +9,12 @@ module Solargraph
     class SyntaxError < StandardError
     end
 
-    def self.rubyvm?
-      false
-    end
-
     # @deprecated
     Legacy = ParserGem
 
     ClassMethods = ParserGem::ClassMethods
-
+    # @todo should be able to just 'extend ClassMethods' here and
+    #   typecheck things off it in strict mode
     extend ParserGem::ClassMethods
 
     NodeMethods = ParserGem::NodeMethods

data/lib/solargraph/pin/base.rb

@@ -15,6 +15,9 @@ module Solargraph
       # @return [Solargraph::Location]
       attr_reader :location
 
+      # @return [Solargraph::Location]
+      attr_reader :type_location
+
       # @return [String]
       attr_reader :name
 
@@ -25,11 +28,13 @@ module Solargraph
       attr_accessor :source
 
       # @param location [Solargraph::Location, nil]
+      # @param type_location [Solargraph::Location, nil]
       # @param closure [Solargraph::Pin::Closure, nil]
       # @param name [String]
       # @param comments [String]
-      def initialize location: nil, closure: nil, name: '', comments: ''
+      def initialize location: nil, type_location: nil, closure: nil, name: '', comments: ''
         @location = location
+        @type_location = type_location
         @closure = closure
         @name = name
         @comments = comments
@@ -70,6 +75,10 @@ module Solargraph
         transformed.erase_generics(definitions.generics)
       end
 
+      def all_rooted?
+        !return_type || return_type.all_rooted?
+      end
+
       # @param generics_to_erase [Enumerable<String>]
       # @return [self]
       def erase_generics(generics_to_erase)
@@ -102,6 +111,11 @@ module Solargraph
         false
       end
 
+      # @return [Location, nil]
+      def best_location
+        location || type_location
+      end
+
       # Pin equality is determined using the #nearly? method and also
       # requiring both pins to have the same location.
       #

data/lib/solargraph/pin/base_variable.rb

@@ -57,7 +57,7 @@ module Solargraph
             # Use the return node for inference. The clip might infer from the
             # first node in a method call instead of the entire call.
             chain = Parser.chain(node, nil, nil)
-            result = chain.infer(api_map, closure, clip.locals).self_to(closure.context.tag)
+            result = chain.infer(api_map, closure, clip.locals).self_to_type(closure.context)
             types.push result unless result.undefined?
           end
         end

data/lib/solargraph/pin/block.rb

@@ -2,7 +2,7 @@
 
 module Solargraph
   module Pin
-    class Block < Closure
+    class Block < Callable
       # @return [Parser::AST::Node]
       attr_reader :receiver
 
@@ -14,10 +14,9 @@ module Solargraph
       # @param context [ComplexType, nil]
       # @param args [::Array<Parameter>]
       def initialize receiver: nil, args: [], context: nil, node: nil, **splat
-        super(**splat)
+        super(**splat, parameters: args)
         @receiver = receiver
         @context = context
-        @parameters = args
         @return_type = ComplexType.parse('::Proc')
         @node = node
       end
@@ -32,16 +31,6 @@ module Solargraph
         @rebind&.defined? ? @rebind : closure.binder
       end
 
-      # @return [::Array<Parameter>]
-      def parameters
-        @parameters ||= []
-      end
-
-      # @return [::Array<String>]
-      def parameter_names
-        @parameter_names ||= parameters.map(&:name)
-      end
-
       # @param yield_types [::Array<ComplexType>]
       # @param parameters [::Array<Parameter>]
       #
@@ -57,13 +46,6 @@ module Solargraph
         parameters.map { ComplexType::UNDEFINED }
       end
 
-      # @todo the next step with parameters, arguments, destructuring,
-      #   kwargs, etc logic is probably either creating a Parameters
-      #   or Callable pin that encapsulates and shares the logic
-      #   between methods, blocks and signatures.  It could live in
-      #   Signature if Method didn't also own potentially different
-      #   set of parameters, generics and return types.
-
       # @param api_map [ApiMap]
       # @return [::Array<ComplexType>]
       def typify_parameters(api_map)
@@ -87,7 +69,7 @@ module Solargraph
                 namespace_pin = api_map.get_namespace_pins(meth.namespace, closure.namespace).first
                 arg_type.resolve_generics(namespace_pin, param_type)
               else
-                arg_type.self_to(chain.base.infer(api_map, self, locals).namespace).qualify(api_map, meth.context.namespace)
+                arg_type.self_to_type(chain.base.infer(api_map, self, locals)).qualify(api_map, meth.context.namespace)
               end
             end
           end
@@ -105,7 +87,7 @@ module Solargraph
 
         chain = Parser.chain(receiver, location.filename)
         locals = api_map.source_map(location.filename).locals_at(location)
-        receiver_pin = chain.define(api_map, self, locals).first
+        receiver_pin = chain.define(api_map, closure, locals).first
         return ComplexType::UNDEFINED unless receiver_pin
 
         types = receiver_pin.docstring.tag(:yieldreceiver)&.types
@@ -114,7 +96,7 @@ module Solargraph
         target = chain.base.infer(api_map, receiver_pin, locals)
         target = full_context unless target.defined?
 
-        ComplexType.try_parse(*types).qualify(api_map, receiver_pin.context.namespace).self_to(target.to_s)
+        ComplexType.try_parse(*types).qualify(api_map, receiver_pin.context.namespace).self_to_type(target)
       end
     end
   end

data/lib/solargraph/pin/callable.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    class Callable < Closure
+      # @return [self]
+      attr_reader :block
+
+      attr_reader :parameters
+
+      # @return [ComplexType, nil]
+      attr_reader :return_type
+
+      # @param block [Signature, nil]
+      # @param return_type [ComplexType, nil]
+      # @param parameters [::Array<Pin::Parameter>]
+      def initialize block: nil, return_type: nil, parameters: [], **splat
+        super(**splat)
+        @block = block
+        @return_type = return_type
+        @parameters = parameters
+      end
+
+      # @return [::Array<String>]
+      def parameter_names
+        @parameter_names ||= parameters.map(&:name)
+      end
+
+      # @param generics_to_resolve [Enumerable<String>]
+      # @param arg_types [Array<ComplexType>, nil]
+      # @param return_type_context [ComplexType, nil]
+      # @param yield_arg_types [Array<ComplexType>, nil]
+      # @param yield_return_type_context [ComplexType, nil]
+      # @param context [ComplexType, nil]
+      # @param resolved_generic_values [Hash{String => ComplexType}]
+      # @return [self]
+      def resolve_generics_from_context(generics_to_resolve,
+                                        arg_types = nil,
+                                        return_type_context = nil,
+                                        yield_arg_types = nil,
+                                        yield_return_type_context = nil,
+                                        resolved_generic_values: {})
+        callable = super(generics_to_resolve, return_type_context, resolved_generic_values: resolved_generic_values)
+        callable.parameters = callable.parameters.each_with_index.map do |param, i|
+          if arg_types.nil?
+            param.dup
+          else
+            param.resolve_generics_from_context(generics_to_resolve,
+                                                arg_types[i],
+                                                resolved_generic_values: resolved_generic_values)
+          end
+        end
+        callable.block = block.resolve_generics_from_context(generics_to_resolve,
+                                                              yield_arg_types,
+                                                              yield_return_type_context,
+                                                              resolved_generic_values: resolved_generic_values) if callable.block?
+        callable
+      end
+
+      # @param generics_to_resolve [Enumerable<String>]
+      # @param arg_types [Array<ComplexType>, nil]
+      # @param return_type_context [ComplexType, nil]
+      # @param yield_arg_types [Array<ComplexType>, nil]
+      # @param yield_return_type_context [ComplexType, nil]
+      # @param context [ComplexType, nil]
+      # @param resolved_generic_values [Hash{String => ComplexType}]
+      # @return [self]
+      def resolve_generics_from_context_until_complete(generics_to_resolve,
+                                                       arg_types = nil,
+                                                       return_type_context = nil,
+                                                       yield_arg_types = nil,
+                                                       yield_return_type_context = nil,
+                                                       resolved_generic_values: {})
+        # See
+        # https://github.com/soutaro/steep/tree/master/lib/steep/type_inference
+        # and
+        # https://github.com/sorbet/sorbet/blob/master/infer/inference.cc
+        # for other implementations
+
+        return self if generics_to_resolve.empty?
+
+        last_resolved_generic_values = resolved_generic_values.dup
+        new_pin = resolve_generics_from_context(generics_to_resolve,
+                                                arg_types,
+                                                return_type_context,
+                                                yield_arg_types,
+                                                yield_return_type_context,
+                                                resolved_generic_values: resolved_generic_values)
+        if last_resolved_generic_values == resolved_generic_values
+          # erase anything unresolved
+          return new_pin.erase_generics(self.generics)
+        end
+        new_pin.resolve_generics_from_context_until_complete(generics_to_resolve,
+                                                             arg_types,
+                                                             return_type_context,
+                                                             yield_arg_types,
+                                                             yield_return_type_context,
+                                                             resolved_generic_values: resolved_generic_values)
+      end
+
+      # @return [Array<String>]
+      # @yieldparam [ComplexType]
+      # @yieldreturn [ComplexType]
+      # @return [self]
+      def transform_types(&transform)
+        # @todo 'super' alone should work here I think, but doesn't typecheck at level typed
+        callable = super(&transform)
+        callable.block = block.transform_types(&transform) if block?
+        callable.parameters = parameters.map do |param|
+          param.transform_types(&transform)
+        end
+        callable
+      end
+
+      # @param arguments [::Array<Chain>]
+      # @param signature [Pin::Signature]
+      # @return [Boolean]
+      def arity_matches? arguments, with_block
+        argcount = arguments.length
+        parcount = mandatory_positional_param_count
+        parcount -= 1 if !parameters.empty? && parameters.last.block?
+        return false if block? && !with_block
+        return false if argcount < parcount && !(argcount == parcount - 1 && parameters.last.restarg?)
+        true
+      end
+
+      def mandatory_positional_param_count
+        parameters.count(&:arg?)
+      end
+
+      # @return [String]
+      def to_rbs
+        rbs_generics + '(' + parameters.map { |param| param.to_rbs }.join(', ') + ') ' + (block.nil? ? '' : '{ ' + block.to_rbs + ' } ') + '-> ' + return_type.to_rbs
+      end
+
+      def block?
+        !!@block
+      end
+
+      protected
+
+      attr_writer :block
+
+      attr_writer :parameters
+    end
+  end
+end

data/lib/solargraph/pin/closure.rb

@@ -18,7 +18,7 @@ module Solargraph
         @context ||= begin
           result = super
           if scope == :instance
-            Solargraph::ComplexType.parse(result.namespace)
+            result.reduce_class_type
           else
             result
           end
@@ -42,10 +42,15 @@ module Solargraph
       end
 
       # @return [String]
-      def generics_as_rbs
+      def to_rbs
+        rbs_generics + return_type.to_rbs
+      end
+
+      # @return [String]
+      def rbs_generics
         return '' if generics.empty?
 
-        generics.join(', ') + ' '
+        '[' + generics.map { |gen| gen.to_s }.join(', ') + '] '
       end
     end
   end