solargraph 0.53.3 → 0.54.0

data/lib/solargraph/pin/base_variable.rb

@@ -9,10 +9,14 @@ module Solargraph
       # @return [Parser::AST::Node, nil]
       attr_reader :assignment
 
+      attr_accessor :mass_assignment
+
       # @param assignment [Parser::AST::Node, nil]
       def initialize assignment: nil, **splat
         super(**splat)
         @assignment = assignment
+        # @type [nil, ::Array(Parser::AST::Node, Integer)]
+        @mass_assignment = nil
       end
 
       def completion_item_kind
@@ -36,10 +40,12 @@ module Solargraph
         true
       end
 
-      def probe api_map
-        return ComplexType::UNDEFINED if @assignment.nil?
+      # @param parent_node [Parser::AST::Node]
+      # @param api_map [ApiMap]
+      # @return [::Array<ComplexType>]
+      def return_types_from_node(parent_node, api_map)
         types = []
-        value_position_nodes_only(@assignment).each do |node|
+        value_position_nodes_only(parent_node).each do |node|
           # Nil nodes may not have a location
           if node.nil? || node.type == :NIL || node.type == :nil
             types.push ComplexType::NIL
@@ -55,8 +61,31 @@ module Solargraph
             types.push result unless result.undefined?
           end
         end
-        return ComplexType::UNDEFINED if types.empty?
-        ComplexType.try_parse(*types.map(&:to_s))
+        types
+      end
+
+      # @param api_map [ApiMap]
+      # @return [ComplexType]
+      def probe api_map
+        unless @assignment.nil?
+          types = return_types_from_node(@assignment, api_map)
+          return ComplexType.new(types.uniq) unless types.empty?
+        end
+
+        unless @mass_assignment.nil?
+          mass_node, index = @mass_assignment
+          types = return_types_from_node(mass_node, api_map)
+          types.map! do |type|
+            if type.tuple?
+              type.all_params[index]
+            elsif ['::Array', '::Set', '::Enumerable'].include?(type.rooted_name)
+              type.all_params.first
+            end
+          end.compact!
+          return ComplexType.new(types.uniq) unless types.empty?
+        end
+
+        ComplexType::UNDEFINED
       end
 
       def == other

data/lib/solargraph/pin/block.rb

@@ -18,17 +18,18 @@ module Solargraph
         @receiver = receiver
         @context = context
         @parameters = args
+        @return_type = ComplexType.parse('::Proc')
         @node = node
       end
 
       # @param api_map [ApiMap]
       # @return [void]
       def rebind api_map
-        @binder ||= binder_or_nil(api_map)
+        @rebind ||= maybe_rebind(api_map)
       end
 
       def binder
-        @binder || closure.binder
+        @rebind&.defined? ? @rebind : closure.binder
       end
 
       # @return [::Array<Parameter>]
@@ -41,20 +42,74 @@ module Solargraph
         @parameter_names ||= parameters.map(&:name)
       end
 
+      # @param yield_types [::Array<ComplexType>]
+      # @param parameters [::Array<Parameter>]
+      #
+      # @return [::Array<ComplexType>]
+      def destructure_yield_types(yield_types, parameters)
+        return yield_types if yield_types.length == parameters.length
+
+        # yielding a tuple into a block will destructure the tuple
+        if yield_types.length == 1
+          yield_type = yield_types.first
+          return yield_type.all_params if yield_type.tuple? && yield_type.all_params.length == parameters.length
+        end
+        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)
+        chain = Parser.chain(receiver, filename, node)
+        clip = api_map.clip_at(location.filename, location.range.start)
+        locals = clip.locals - [self]
+        meths = chain.define(api_map, closure, locals)
+        # @todo Convert logic to use signatures
+        meths.each do |meth|
+          next if meth.block.nil?
+
+          yield_types = meth.block.parameters.map(&:return_type)
+          # 'arguments' is what the method says it will yield to the
+          # block; 'parameters' is what the block accepts
+          argument_types = destructure_yield_types(yield_types, parameters)
+          param_types = argument_types.each_with_index.map do |arg_type, idx|
+            param = parameters[idx]
+            param_type = chain.base.infer(api_map, param, locals)
+            unless arg_type.nil?
+              if arg_type.generic? && param_type.defined?
+                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)
+              end
+            end
+          end
+          return param_types if param_types.all?(&:defined?)
+        end
+        parameters.map { ComplexType::UNDEFINED }
+      end
+
       private
 
       # @param api_map [ApiMap]
-      # @return [ComplexType, nil]
-      def binder_or_nil api_map
-        return nil unless receiver
+      # @return [ComplexType]
+      def maybe_rebind api_map
+        return ComplexType::UNDEFINED unless receiver
 
         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
-        return nil unless receiver_pin
+        return ComplexType::UNDEFINED unless receiver_pin
 
         types = receiver_pin.docstring.tag(:yieldreceiver)&.types
-        return nil unless types&.any?
+        return ComplexType::UNDEFINED unless types&.any?
 
         target = chain.base.infer(api_map, receiver_pin, locals)
         target = full_context unless target.defined?

data/lib/solargraph/pin/delegated_method.rb

@@ -11,8 +11,9 @@ module Solargraph
       # given closure/scope, and the delegated method will then be resolved
       # to a method pin on that type.
       #
-      # @param resolved_method [Method] an already resolved method pin.
+      # @param method [Method, nil] an already resolved method pin.
       # @param receiver [Source::Chain, nil] the source code used to resolve the receiver for this delegated method.
+      # @param name [String]
       # @param receiver_method_name [String] the method name that will be called on the receiver (defaults to :name).
       def initialize(method: nil, receiver: nil, name: method&.name, receiver_method_name: name, **splat)
         raise ArgumentError, 'either :method or :receiver is required' if (method && receiver) || (!method && !receiver)
@@ -37,6 +38,7 @@ module Solargraph
         end
       end
 
+      # @param api_map [ApiMap]
       def resolvable?(api_map)
         resolve_method(api_map)
         !!@resolved_method
@@ -79,6 +81,7 @@ module Solargraph
       # helper to print a source chain as code, probably not 100% correct.
       #
       # @param chain [Source::Chain]
+      # @return [String]
       def print_chain(chain)
         out = +''
         chain.links.each_with_index do |link, index|
@@ -91,6 +94,7 @@ module Solargraph
           end
           out << link.word
         end
+        out
       end
     end
   end

data/lib/solargraph/pin/documenting.rb

@@ -76,6 +76,8 @@ module Solargraph
         end
       end
 
+      # @param text [String]
+      # @return [String]
       def self.strip_html_comments text
         text.gsub(/<!--([\s\S]*?)-->/, '').strip
       end

data/lib/solargraph/pin/method.rb

@@ -135,7 +135,7 @@ module Solargraph
           result = []
           result.push generate_signature(parameters, top_type) if top_type.defined?
           result.concat(overloads.map { |meth| generate_signature(meth.parameters, meth.return_type) }) unless overloads.empty?
-          result.push generate_signature(parameters, top_type) if result.empty?
+          result.push generate_signature(parameters, @return_type || ComplexType::UNDEFINED) if result.empty?
           result
         end
       end
@@ -288,7 +288,9 @@ module Solargraph
 
       # @return [::Array<Pin::Method>]
       def overloads
-        @overloads ||= docstring.tags(:overload).map do |tag|
+        # Ignore overload tags with nil parameters. If it's not an array, the
+        # tag's source is likely malformed.
+        @overloads ||= docstring.tags(:overload).select(&:parameters).map do |tag|
           Pin::Signature.new(
             generics,
             tag.parameters.map do |src|

data/lib/solargraph/pin/parameter.rb

@@ -76,6 +76,7 @@ module Solargraph
         end
       end
 
+      # @return [ComplexType]
       def return_type
         if @return_type.nil?
           @return_type = ComplexType::UNDEFINED
@@ -99,7 +100,9 @@ module Solargraph
       #
       # @return [Integer]
       def index
-        closure.parameter_names.index(name)
+        # @type [Method, Block]
+        method_pin = closure
+        method_pin.parameter_names.index(name)
       end
 
       # @param api_map [ApiMap]
@@ -140,33 +143,7 @@ module Solargraph
       # @return [ComplexType]
       def typify_block_param api_map
         if closure.is_a?(Pin::Block) && closure.receiver
-          chain = Parser.chain(closure.receiver, filename, closure.node)
-          clip = api_map.clip_at(location.filename, location.range.start)
-          locals = clip.locals - [self]
-          meths = chain.define(api_map, closure, locals)
-          receiver_type = chain.base.infer(api_map, closure, locals)
-          meths.each do |meth|
-            block_signature = meth.block
-            if block_signature
-              yield_type = block_signature.parameters[index]&.return_type
-            else
-              # @todo move the yieldparam tag parsing logic into the
-              #   creation of Method pins so we don't need this else
-              #   statement
-              yps = meth.docstring.tags(:yieldparam)
-              unless yps[index].nil? or yps[index].types.nil? or yps[index].types.empty?
-                yield_type = ComplexType.try_parse(yps[index].types.first)
-              end
-            end
-            unless yield_type.nil?
-              if yield_type.generic? && receiver_type.defined?
-                namespace_pin = api_map.get_namespace_pins(meth.namespace, closure.namespace).first
-                return yield_type.resolve_generics(namespace_pin, receiver_type)
-              else
-                return yield_type.self_to(chain.base.infer(api_map, closure, locals).namespace).qualify(api_map, meth.context.namespace)
-              end
-            end
-          end
+          return closure.typify_parameters(api_map)[index]
         end
         ComplexType::UNDEFINED
       end

data/lib/solargraph/rbs_map/conversions.rb

@@ -38,6 +38,8 @@ module Solargraph
         environment = RBS::Environment.from_loader(loader).resolve_type_names
         cursor = pins.length
         environment.declarations.each { |decl| convert_decl_to_pin(decl, Solargraph::Pin::ROOT_PIN) }
+        added_pins = pins[cursor..-1]
+        added_pins.each { |pin| pin.source = :rbs }
       end
 
       # @param decl [RBS::AST::Declarations::Base]
@@ -514,13 +516,17 @@ module Solargraph
 
       # @param type_name [RBS::TypeName]
       # @param type_args [Enumerable<RBS::Types::Bases::Base>]
-      # @return [ComplexType]
+      # @return [ComplexType::UniqueType]
       def generic_type(type_name, type_args)
         base = RBS_TO_YARD_TYPE[type_name.relative!.to_s] || type_name.relative!.to_s
-        params = type_args.map { |a| other_type_to_tag(a) }.reject { |t| t == 'undefined' }
-        params_str = params.empty? ? '' : "<#{params.join(', ')}>"
-        type_string = "#{base}#{params_str}"
-        ComplexType.parse(type_string)
+        params = type_args.map { |a| other_type_to_tag(a) }.reject { |t| t == 'undefined' }.map do |t|
+          ComplexType.try_parse(t)
+        end
+        if base == 'Hash' && params.length == 2
+          ComplexType::UniqueType.new(base, [params.first], [params.last], rooted: true, parameters_type: :hash)
+        else
+          ComplexType::UniqueType.new(base, [], params, rooted: true, parameters_type: :list)
+        end
       end
 
       # @param type_name [RBS::TypeName]
@@ -584,7 +590,7 @@ module Solargraph
       end
 
       # @param decl [RBS::AST::Declarations::Class, RBS::AST::Declarations::Module]
-      # @param closure [Pin::Namespace]
+      # @param namespace [Pin::Namespace]
       # @return [void]
       def add_mixins decl, namespace
         decl.each_mixin do |mixin|

data/lib/solargraph/rbs_map/core_fills.rb

@@ -29,7 +29,10 @@ module Solargraph
         Override.from_comment('Module#class_eval', '@yieldreceiver [Class<self>]'),
         Override.from_comment('Module#class_exec', '@yieldreceiver [Class<self>]'),
         Override.from_comment('Module#module_eval', '@yieldreceiver [Module<self>]'),
-        Override.from_comment('Module#module_exec', '@yieldreceiver [Module<self>]')
+        Override.from_comment('Module#module_exec', '@yieldreceiver [Module<self>]'),
+        # RBS does not define Class with a generic, so all calls to
+        # generic() return an 'untyped'.  We can do better:
+        Override.method_return('Class#allocate', 'self')
       ]
 
       # HACK: Add Errno exception classes

data/lib/solargraph/rbs_map.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'pathname'
 require 'rbs'
 
 module Solargraph
@@ -17,10 +18,13 @@ module Solargraph
     attr_reader :library
 
     # @param library [String]
-    def initialize library, version = nil
+    # @param version [String, nil]
+    # @param directories [Array<Pathname, String>]
+    def initialize library, version = nil, directories: []
       @library = library
       @version = version
       @collection = nil
+      @directories = directories
       loader = RBS::EnvironmentLoader.new(core_root: nil, repository: repository)
       add_library loader, library, version
       return unless resolved?
@@ -47,7 +51,11 @@ module Solargraph
     end
 
     def repository
-      @repository ||= RBS::Repository.new(no_stdlib: false)
+      @repository ||= RBS::Repository.new(no_stdlib: false).tap do |repo|
+        # @todo Temporarily ignoring external directories due to issues with
+        #   incomplete/broken gem_rbs_collection installations
+        # @directories.each { |dir| repo.add(Pathname.new(dir)) }
+      end
     end
 
     # @param library [String]
@@ -71,7 +79,7 @@ module Solargraph
         Solargraph.logger.info "#{short_name} successfully loaded library #{library}"
         true
       else
-        Solargraph.logger.debug "#{short_name} failed to load library #{library}"
+        Solargraph.logger.info "#{short_name} failed to load library #{library}"
         false
       end
     end

data/lib/solargraph/shell.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'benchmark'
 require 'thor'
 require 'yard'
 
@@ -149,23 +150,28 @@ module Solargraph
     # @return [void]
     def typecheck *files
       directory = File.realpath(options[:directory])
-      api_map = Solargraph::ApiMap.load_with_cache(directory)
+      api_map = Solargraph::ApiMap.load_with_cache(directory, $stdout)
+      probcount = 0
       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
+
+      time = Benchmark.measure {
+        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 "Typecheck finished in #{time.real} seconds."
       puts "#{probcount} problem#{probcount != 1 ? 's' : ''} found#{files.length != 1 ? " in #{filecount} of #{files.length} files" : ''}."
       # "
       exit 1 if probcount > 0
@@ -182,11 +188,10 @@ module Solargraph
     option :verbose, type: :boolean, aliases: :v, desc: 'Verbose output', default: false
     # @return [void]
     def scan
-      require 'benchmark'
       directory = File.realpath(options[:directory])
       api_map = nil
       time = Benchmark.measure {
-        api_map = Solargraph::ApiMap.load_with_cache(directory)
+        api_map = Solargraph::ApiMap.load_with_cache(directory, $stdout)
         api_map.pins.each do |pin|
           begin
             puts pin_description(pin) if options[:verbose]

data/lib/solargraph/source/chain.rb

@@ -29,6 +29,8 @@ module Solargraph
 
       @@inference_stack = []
       @@inference_depth = 0
+      @@inference_invalidation_key = nil
+      @@inference_cache = {}
 
       UNDEFINED_CALL = Chain::Call.new('<undefined>')
       UNDEFINED_CONSTANT = Chain::Constant.new('<undefined>')
@@ -81,7 +83,25 @@ module Solargraph
       # @param name_pin [Pin::Base]
       # @param locals [::Enumerable<Pin::LocalVariable>]
       # @return [ComplexType]
+      # @sg-ignore
       def infer api_map, name_pin, locals
+        out = nil
+        cached = @@inference_cache[[node, node.location, links.map(&:word), name_pin&.return_type, locals]] unless node.nil?
+        return cached if cached && @@inference_invalidation_key == api_map.hash
+        out = infer_uncached api_map, name_pin, locals
+        if @@inference_invalidation_key != api_map.hash
+          @@inference_cache = {}
+          @@inference_invalidation_key = api_map.hash
+        end
+        @@inference_cache[[node, node.location, links.map(&:word), name_pin&.return_type, locals]] = out unless node.nil?
+        out
+      end
+
+      # @param api_map [ApiMap]
+      # @param name_pin [Pin::Base]
+      # @param locals [::Enumerable<Pin::LocalVariable>]
+      # @return [ComplexType]
+      def infer_uncached api_map, name_pin, locals
         from_here = base.infer(api_map, name_pin, locals) unless links.length == 1
         if from_here
           name_pin = name_pin.proxy(from_here)

data/lib/solargraph/source/updater.rb

@@ -42,6 +42,7 @@ module Solargraph
         @output
       end
 
+      # @param text [String]
       # @return [String]
       def repair text
         changes.each do |ch|

data/lib/solargraph/source.rb

@@ -92,50 +92,6 @@ module Solargraph
       stack
     end
 
-    # Start synchronizing the source. This method updates the code without
-    # parsing a new AST. The resulting Source object will be marked not
-    # synchronized (#synchronized? == false).
-    #
-    # @param updater [Source::Updater]
-    # @return [Source]
-    def start_synchronize updater
-      raise 'Invalid synchronization' unless updater.filename == filename
-      real_code = updater.write(@code)
-      src = Source.allocate
-      src.filename = filename
-      src.code = real_code
-      src.version = updater.version
-      src.parsed = parsed?
-      src.repaired = updater.repair(@repaired)
-      src.synchronized = false
-      src.node = @node
-      src.comments = @comments
-      src.error_ranges = error_ranges
-      src.last_updater = updater
-      return src.finish_synchronize unless real_code.lines.length == @code.lines.length
-      src
-    end
-
-    # Finish synchronizing a source that was updated via #start_synchronize.
-    # This method returns self if the source is already synchronized. Otherwise
-    # it parses the AST and returns a new synchronized Source.
-    #
-    # @return [Source]
-    def finish_synchronize
-      return self if synchronized?
-      synced = Source.new(@code, filename)
-      if synced.parsed?
-        synced.version = version
-        return synced
-      end
-      synced = Source.new(@repaired, filename)
-      synced.error_ranges.concat (error_ranges + last_updater.changes.map(&:range))
-      synced.code = @code
-      synced.synchronized = true
-      synced.version = version
-      synced
-    end
-
     # Synchronize the Source with an update. This method applies changes to the
     # code, parses the new code's AST, and returns the resulting Source object.
     #

data/lib/solargraph/source_map/clip.rb

@@ -11,6 +11,7 @@ module Solargraph
       def initialize api_map, cursor
         @api_map = api_map
         @cursor = cursor
+        block.rebind(api_map) if block.is_a?(Pin::Block)
       end
 
       # @return [Array<Pin::Base>] Relevant pins for infering the type of the Cursor's position

data/lib/solargraph/source_map/mapper.rb

@@ -144,7 +144,7 @@ module Solargraph
             )
           end
           if t.nil? || t.include?('w')
-            pins.push Solargraph::Pin::Method.new(
+            method_pin = Solargraph::Pin::Method.new(
               location: location,
               closure: namespace,
               name: "#{directive.tag.name}=",
@@ -153,7 +153,8 @@ module Solargraph
               visibility: :public,
               attribute: true
             )
-            pins.last.parameters.push Pin::Parameter.new(name: 'value', decl: :arg, closure: pins.last)
+            pins.push method_pin
+            method_pin.parameters.push Pin::Parameter.new(name: 'value', decl: :arg, closure: pins.last)
             if pins.last.return_type.defined?
               pins.last.docstring.add_tag YARD::Tags::Tag.new(:param, '', pins.last.return_type.to_s.split(', '), 'value')
             end

data/lib/solargraph/source_map.rb

@@ -40,6 +40,16 @@ module Solargraph
       @pin_select_cache[klass] ||= @pin_class_hash.select { |key, _| key <= klass }.values.flatten
     end
 
+    # A hash representing the state of the source map's API.
+    #
+    # ApiMap#catalog uses this value to determine whether it needs to clear its
+    # cache.
+    #
+    # @return [Integer]
+    def api_hash
+      @api_hash ||= (pins_by_class(Pin::Constant) + pins_by_class(Pin::Namespace).select { |pin| pin.namespace.to_s > '' } + pins_by_class(Pin::Reference) + pins_by_class(Pin::Method).map(&:node)).hash
+    end
+
     # @return [String]
     def filename
       source.filename