solargraph 0.54.4 → 0.57.0

data/lib/solargraph/bench.rb

@@ -11,18 +11,35 @@ module Solargraph
     # @return [Workspace]
     attr_reader :workspace
 
+    # @return [SourceMap]
+    attr_reader :live_map
+
     # @return [Set<String>]
     attr_reader :external_requires
 
     # @param source_maps [Array<SourceMap>, Set<SourceMap>]
     # @param workspace [Workspace]
+    # @param live_map [SourceMap, nil]
     # @param external_requires [Array<String>, Set<String>]
-    def initialize source_maps: [], workspace: Workspace.new, external_requires: []
+    def initialize source_maps: [], workspace: Workspace.new, live_map: nil, external_requires: []
       @source_maps = source_maps.to_set
       @workspace = workspace
+      @live_map = live_map
       @external_requires = external_requires.reject { |path| workspace.would_require?(path) }
                                             .compact
                                             .to_set
     end
+
+    # @return [Hash{String => SourceMap}]
+    def source_map_hash
+      # @todo Work around #to_h bug in current Ruby head (3.5) with #map#to_h
+      @source_map_hash ||= source_maps.map { |s| [s.filename, s] }
+                                      .to_h
+    end
+
+    # @return [Set<SourceMap>]
+    def icebox
+      @icebox ||= (source_maps - [live_map])
+    end
   end
 end

data/lib/solargraph/complex_type/type_methods.rb

@@ -88,6 +88,7 @@ module Solargraph
       # @return [Symbol, nil]
       attr_reader :parameters_type
 
+      # @type [Hash{String => Symbol}]
       PARAMETERS_TYPE_BY_STARTING_TAG = {
         '{' => :hash,
         '(' => :fixed,
@@ -129,6 +130,7 @@ module Solargraph
         end.call
       end
 
+      # @return [self]
       def namespace_type
         return ComplexType.parse('::Object') if duck_type?
         return ComplexType.parse('::NilClass') if nil_type?
@@ -171,7 +173,11 @@ module Solargraph
         elsif fixed_parameters?
           "(#{subtypes_str})"
         else
-          "<#{subtypes_str}>"
+          if name == 'Hash'
+            "<#{key_types_str}, #{subtypes_str}>"
+          else
+            "<#{key_types_str}#{subtypes_str}>"
+          end
         end
       end
 

data/lib/solargraph/complex_type/unique_type.rb

@@ -27,7 +27,7 @@ module Solargraph
       # @return [UniqueType]
       def self.parse name, substring = '', make_rooted: nil
         if name.start_with?(':::')
-          raise "Illegal prefix: #{name}"
+          raise ComplexTypeError, "Illegal prefix: #{name}"
         end
         if name.start_with?('::')
           name = name[2..-1]
@@ -48,12 +48,15 @@ module Solargraph
           subs = ComplexType.parse(substring[1..-2], partial: true)
           parameters_type = PARAMETERS_TYPE_BY_STARTING_TAG.fetch(substring[0])
           if parameters_type == :hash
-            raise ComplexTypeError, "Bad hash type" unless !subs.is_a?(ComplexType) and subs.length == 2 and !subs[0].is_a?(UniqueType) and !subs[1].is_a?(UniqueType)
-            # @todo should be able to resolve map; both types have it
-            #   with same return type
-            # @sg-ignore
+            raise ComplexTypeError, "Bad hash type: name=#{name}, substring=#{substring}" unless !subs.is_a?(ComplexType) and subs.length == 2 and !subs[0].is_a?(UniqueType) and !subs[1].is_a?(UniqueType)
+            key_types.concat(subs[0].map { |u| ComplexType.new([u]) })
+            subtypes.concat(subs[1].map { |u| ComplexType.new([u]) })
+          elsif parameters_type == :list && name == 'Hash'
+            # Treat Hash<A, B> as Hash{A => B}
+            if subs.length != 2
+              raise ComplexTypeError, "Bad hash type: name=#{name}, substring=#{substring} - must have exactly two parameters"
+            end
             key_types.concat(subs[0].map { |u| ComplexType.new([u]) })
-            # @sg-ignore
             subtypes.concat(subs[1].map { |u| ComplexType.new([u]) })
           else
             subtypes.concat subs
@@ -73,19 +76,66 @@ module Solargraph
         end
         raise "Please remove leading :: and set rooted instead - #{name.inspect}" if name.start_with?('::')
         @name = name
-        @key_types = key_types
-        @subtypes = subtypes
+        @parameters_type = parameters_type
+        if implicit_union?
+          @key_types = key_types.uniq
+          @subtypes = subtypes.uniq
+        else
+          @key_types = key_types
+          @subtypes = subtypes
+        end
         @rooted = rooted
         @all_params = []
-        @all_params.concat key_types
-        @all_params.concat subtypes
-        @parameters_type = parameters_type
+        @all_params.concat @key_types
+        @all_params.concat @subtypes
+      end
+
+      def implicit_union?
+        # @todo use api_map to establish number of generics in type;
+        #   if only one is allowed but multiple are passed in, treat
+        #   those as implicit unions
+        ['Hash', 'Array', 'Set', '_ToAry', 'Enumerable', '_Each'].include?(name) && parameters_type != :fixed
       end
 
       def to_s
         tag
       end
 
+      # @return [self]
+      def simplify_literals
+        transform do |t|
+          next t unless t.literal?
+          t.recreate(new_name: t.non_literal_name)
+        end
+      end
+
+      def literal?
+        non_literal_name != name
+      end
+
+      # @return [String]
+      def non_literal_name
+        @non_literal_name ||= determine_non_literal_name
+      end
+
+      # @return [String]
+      def determine_non_literal_name
+        # https://github.com/ruby/rbs/blob/master/docs/syntax.md
+        #
+        # _literal_ ::= _string-literal_
+        #    | _symbol-literal_
+        #    | _integer-literal_
+        #    | `true`
+        #    | `false`
+        return name if name.empty?
+        return 'NilClass' if name == 'nil'
+        return 'Boolean' if ['true', 'false'].include?(name)
+        return 'Symbol' if name[0] == ':'
+        return 'String' if ['"', "'"].include?(name[0])
+        return 'Integer' if name.match?(/^-?\d+$/)
+        name
+      end
+
       def eql?(other)
         self.class == other.class &&
           @name == other.name &&
@@ -113,11 +163,14 @@ module Solargraph
       def rbs_name
         if name == 'undefined'
           'untyped'
+        elsif literal?
+          name
         else
           rooted_name
         end
       end
 
+      # @return [String]
       def desc
         rooted_tags
       end
@@ -183,9 +236,26 @@ module Solargraph
         name == GENERIC_TAG_NAME || all_params.any?(&:generic?)
       end
 
+      # @param api_map [ApiMap] The ApiMap that performs qualification
+      # @param atype [ComplexType] type which may be assigned to this type
+      def can_assign?(api_map, atype)
+        logger.debug { "UniqueType#can_assign?(self=#{rooted_tags.inspect}, atype=#{atype.rooted_tags.inspect})" }
+        downcasted_atype = atype.downcast_to_literal_if_possible
+        out = downcasted_atype.all? do |autype|
+          autype.name == name || api_map.super_and_sub?(name, autype.name)
+        end
+        logger.debug { "UniqueType#can_assign?(self=#{rooted_tags.inspect}, atype=#{atype.rooted_tags.inspect}) => #{out}" }
+        out
+      end
+
+      # @return [UniqueType]
+      def downcast_to_literal_if_possible
+        SINGLE_SUBTYPE.fetch(rooted_tag, self)
+      end
+
       # @param generics_to_resolve [Enumerable<String>]
       # @param context_type [UniqueType, nil]
-      # @param resolved_generic_values [Hash{String => ComplexType}] Added to as types are encountered or resolved
+      # @param resolved_generic_values [Hash{String => ComplexType, ComplexType::UniqueType}] Added to as types are encountered or resolved
       # @return [UniqueType, ComplexType]
       def resolve_generics_from_context generics_to_resolve, context_type, resolved_generic_values: {}
         if name == ComplexType::GENERIC_TAG_NAME
@@ -243,7 +313,8 @@ module Solargraph
 
         transform(name) do |t|
           if t.name == GENERIC_TAG_NAME
-            idx = definitions.generics.index(t.subtypes.first&.name)
+            generic_name = t.subtypes.first&.name
+            idx = definitions.generics.index(generic_name)
             next t if idx.nil?
             if context_type.parameters_type == :hash
               if idx == 0
@@ -253,8 +324,14 @@ module Solargraph
               else
                 next ComplexType::UNDEFINED
               end
+            elsif context_type.all?(&:implicit_union?)
+              if idx == 0 && !context_type.all_params.empty?
+                ComplexType.new(context_type.all_params)
+              else
+                ComplexType::UNDEFINED
+              end
             else
-              context_type.all_params[idx] || ComplexType::UNDEFINED
+              context_type.all_params[idx] || definitions.generic_defaults[generic_name] || ComplexType::UNDEFINED
             end
           else
             t
@@ -276,9 +353,9 @@ module Solargraph
 
       # @param new_name [String, nil]
       # @param make_rooted [Boolean, nil]
-      # @param new_key_types [Array<UniqueType>, nil]
+      # @param new_key_types [Array<ComplexType>, nil]
       # @param rooted [Boolean, nil]
-      # @param new_subtypes [Array<UniqueType>, nil]
+      # @param new_subtypes [Array<ComplexType>, nil]
       # @return [self]
       def recreate(new_name: nil, make_rooted: nil, new_key_types: nil, new_subtypes: nil)
         raise "Please remove leading :: and set rooted instead - #{new_name}" if new_name&.start_with?('::')
@@ -381,6 +458,18 @@ module Solargraph
 
       UNDEFINED = UniqueType.new('undefined', rooted: false)
       BOOLEAN = UniqueType.new('Boolean', rooted: true)
+      TRUE = UniqueType.new('true', rooted: true)
+      FALSE = UniqueType.new('false', rooted: true)
+      NIL = UniqueType.new('nil', rooted: true)
+      # @type [Hash{String => UniqueType}]
+      SINGLE_SUBTYPE = {
+        '::TrueClass' => UniqueType::TRUE,
+        '::FalseClass' => UniqueType::FALSE,
+        '::NilClass' => UniqueType::NIL
+      }.freeze
+
+
+      include Logging
     end
   end
 end

data/lib/solargraph/complex_type.rb

@@ -16,7 +16,13 @@ module Solargraph
     def initialize types = [UniqueType::UNDEFINED]
       # @todo @items here should not need an annotation
       # @type [Array<UniqueType>]
-      @items = types.flat_map(&:items).uniq(&:to_s)
+      items = types.flat_map(&:items).uniq(&:to_s)
+      if items.any? { |i| i.name == 'false' } && items.any? { |i| i.name == 'true' }
+        items.delete_if { |i| i.name == 'false' || i.name == 'true' }
+        items.unshift(ComplexType::BOOLEAN)
+      end
+      items = [UniqueType::UNDEFINED] if items.any?(&:undefined?)
+      @items = items
     end
 
     # @sg-ignore Fix "Not enough arguments to Module#protected"
@@ -70,7 +76,7 @@ module Solargraph
     end
 
     # @yieldparam [UniqueType]
-    # @return [Array]
+    # @return [Array<UniqueType>]
     def map &block
       @items.map &block
     end
@@ -93,6 +99,12 @@ module Solargraph
       end
     end
 
+    # @param atype [ComplexType] type which may be assigned to this type
+    # @param api_map [ApiMap] The ApiMap that performs qualification
+    def can_assign?(api_map, atype)
+      any? { |ut| ut.can_assign?(api_map, atype) }
+    end
+
     # @return [Integer]
     def length
       @items.length
@@ -103,10 +115,6 @@ module Solargraph
       @items
     end
 
-    def tags
-      @items.map(&:tag).join(', ')
-    end
-
     # @param index [Integer]
     # @return [UniqueType]
     def [](index)
@@ -147,10 +155,31 @@ module Solargraph
       map(&:tag).join(', ')
     end
 
+    # @return [String]
+    def tags
+      map(&:tag).join(', ')
+    end
+
+    # @return [String]
+    def simple_tags
+      simplify_literals.tags
+    end
+
+    def literal?
+      @items.any?(&:literal?)
+    end
+
+    # @return [ComplexType]
+    def downcast_to_literal_if_possible
+      ComplexType.new(items.map(&:downcast_to_literal_if_possible))
+    end
+
+    # @return [String]
     def desc
       rooted_tags
     end
 
+    # @return [String]
     def rooted_tags
       map(&:rooted_tag).join(', ')
     end
@@ -175,6 +204,11 @@ module Solargraph
       any?(&:generic?)
     end
 
+    # @return [self]
+    def simplify_literals
+      ComplexType.new(map(&:simplify_literals))
+    end
+
     # @param new_name [String, nil]
     # @yieldparam t [UniqueType]
     # @yieldreturn [UniqueType]
@@ -270,7 +304,6 @@ module Solargraph
       # #  @todo Need ability to use a literal true as a type below
       # #  @param partial [Boolean] True if the string is part of a another type
       # #  @return [Array<UniqueType>]
-      # @sg-ignore
       # @todo To be able to select the right signature above,
       #   Chain::Call needs to know the decl type (:arg, :optarg,
       #   :kwarg, etc) of the arguments given, instead of just having

data/lib/solargraph/convention/active_support_concern.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Convention
+    # ActiveSupport::Concern is syntactic sugar for a common
+    # pattern to include class methods while mixing-in a Module
+    # See https://api.rubyonrails.org/classes/ActiveSupport/Concern.html
+    class ActiveSupportConcern < Base
+      include Logging
+
+      # @return [Array<Pin::Base>]
+      attr_reader :pins
+
+      # @param api_map [ApiMap]
+      # @param rooted_tag [String]
+      # @param scope [Symbol] :class or :instance
+      # @param visibility [Array<Symbol>] :public, :protected, and/or :private
+      # @param deep [Boolean] whether to include methods from included modules
+      # @param skip [Set<String>]
+      # @param _no_core [Boolean]n whether to skip core methods
+      def object api_map, rooted_tag, scope, visibility, deep, skip, _no_core
+        moo = ObjectProcessor.new(api_map, rooted_tag, scope, visibility, deep, skip)
+        moo.environ
+      end
+
+      # yard-activesupport-concern pulls methods inside
+      # 'class_methods' blocks into main class visible from YARD
+      #
+      # @param _doc_map [DocMap]
+      def global _doc_map
+        Environ.new(yard_plugins: ['activesupport-concern'])
+      end
+
+      # Process an object to add any class methods brought in via
+      # ActiveSupport::Concern
+      class ObjectProcessor
+        include Logging
+
+        attr_reader :environ
+
+        # @param api_map [ApiMap]
+        # @param rooted_tag [String] the tag of the class or module being processed
+        # @param scope [Symbol] :class or :instance
+        # @param visibility [Array<Symbol>] :public, :protected, and/or :private
+        # @param deep [Boolean] whether to include methods from included modules
+        # @param skip [Set<String>] a set of tags to skip
+        def initialize api_map, rooted_tag, scope, visibility, deep, skip
+          @api_map = api_map
+          @rooted_tag = rooted_tag
+          @scope = scope
+          @visibility = visibility
+          @deep = deep
+          @skip = skip
+
+          @environ = Environ.new
+          return unless scope == :class
+
+          @rooted_type = ComplexType.parse(rooted_tag).force_rooted
+          @fqns = rooted_type.namespace
+          @namespace_pin = api_map.get_path_pins(fqns).select { |p| p.is_a?(Pin::Namespace) }.first
+
+          api_map.get_includes(fqns).reverse.each do |include_tag|
+            process_include include_tag
+          end
+        end
+
+        private
+
+        attr_reader :api_map, :rooted_tag, :rooted_type, :scope,
+                    :visibility, :deep, :skip, :namespace_pin,
+                    :fqns
+
+        # @param include_tag [Pin::Reference::Include] the include reference pin
+        #
+        # @return [void]
+        def process_include include_tag
+          rooted_include_tag = api_map.dereference(include_tag)
+          return if rooted_include_tag.nil?
+          logger.debug do
+            "ActiveSupportConcern#object(#{fqns}, #{scope}, #{visibility}, #{deep}) - " \
+              "Handling class include include_tag=#{include_tag}"
+          end
+          module_extends = api_map.get_extends(rooted_include_tag).map(&:parametrized_tag).map(&:to_s)
+          logger.debug do
+            "ActiveSupportConcern#object(#{fqns}, #{scope}, #{visibility}, #{deep}) - " \
+              "found module extends of #{rooted_include_tag}: #{module_extends}"
+          end
+          return unless module_extends.include? 'ActiveSupport::Concern'
+          included_class_pins = api_map.inner_get_methods_from_reference(rooted_include_tag, namespace_pin, rooted_type,
+                                                                         :class, visibility, deep, skip, true)
+          logger.debug do
+            "ActiveSupportConcern#object(#{fqns}, #{scope}, #{visibility}, #{deep}) - " \
+              "Found #{included_class_pins.length} inluded class methods for #{rooted_include_tag}"
+          end
+          environ.pins.concat included_class_pins
+          # another pattern is to put class methods inside a submodule
+          classmethods_include_tag = "#{rooted_include_tag}::ClassMethods"
+          included_classmethods_pins =
+            api_map.inner_get_methods_from_reference(classmethods_include_tag, namespace_pin, rooted_type,
+                                                     :instance, visibility, deep, skip, true)
+          logger.debug do
+            "ActiveSupportConcern#object(#{fqns}, #{scope}, #{visibility}, #{deep}) - " \
+              "Found #{included_classmethods_pins.length} included classmethod " \
+              "class methods for #{classmethods_include_tag}"
+          end
+          environ.pins.concat included_classmethods_pins
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/convention/base.rb

@@ -20,12 +20,29 @@ module Solargraph
         EMPTY_ENVIRON
       end
 
-      # The Environ for a YARD map.
+      # The Environ for a DocMap.
       # Subclasses can override this method.
       #
-      # @param yard_map [YardMap]
+      # @param doc_map [DocMap]
       # @return [Environ]
-      def global yard_map
+      def global doc_map
+        EMPTY_ENVIRON
+      end
+
+      # Provides any additional method pins based on e the described object.
+      #
+      # @param api_map [ApiMap]
+      # @param rooted_tag [String] A fully qualified namespace, with
+      #   generic parameter values if applicable
+      # @param scope [Symbol] :class or :instance
+      # @param visibility [Array<Symbol>] :public, :protected, and/or :private
+      # @param deep [Boolean]
+      # @param skip [Set<String>]
+      # @param no_core [Boolean] Skip core classes if true
+      #
+      # @return [Environ]
+      def object api_map, rooted_tag, scope, visibility,
+                 deep, skip, no_core
         EMPTY_ENVIRON
       end
     end

data/lib/solargraph/convention/data_definition/data_assignment_node.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Convention
+    module DataDefinition
+      # A node wrapper for a Data definition via const assignment.
+      # @example
+      #   MyData = Data.new(:bar, :baz) do
+      #     def foo
+      #     end
+      #   end
+      class DataAssignmentNode < DataDefintionNode
+        class << self
+          # @example
+          # s(:casgn, nil, :Foo,
+          #   s(:block,
+          #     s(:send,
+          #       s(:const, nil, :Data), :define,
+          #       s(:sym, :bar),
+          #       s(:sym, :baz)),
+          #     s(:args),
+          #     s(:def, :foo,
+          #       s(:args),
+          #       s(:send, nil, :bar))))
+          # @param node [::Parser::AST::Node]
+          def match?(node)
+            return false unless node&.type == :casgn
+            return false if node.children[2].nil?
+
+            data_node = if node.children[2].type == :block
+                          node.children[2].children[0]
+                        else
+                          node.children[2]
+                        end
+
+            data_definition_node?(data_node)
+          end
+        end
+
+        def class_name
+          if node.children[0]
+            Parser::NodeMethods.unpack_name(node.children[0]) + "::#{node.children[1]}"
+          else
+            node.children[1].to_s
+          end
+        end
+
+        private
+
+        # @return [Parser::AST::Node]
+        def data_node
+          if node.children[2].type == :block
+            node.children[2].children[0]
+          else
+            node.children[2]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/convention/data_definition/data_definition_node.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Convention
+    module DataDefinition
+      # A node wrapper for a Data definition via inheritance.
+      # @example
+      #   class MyData < Data.new(:bar, :baz)
+      #     def foo
+      #     end
+      #   end
+      class DataDefintionNode
+        class << self
+          # @example
+          #   s(:class,
+          #     s(:const, nil, :Foo),
+          #     s(:send,
+          #       s(:const, nil, :Data), :define,
+          #       s(:sym, :bar),
+          #       s(:sym, :baz)),
+          #       s(:hash,
+          #         s(:pair,
+          #           s(:sym, :keyword_init),
+          #           s(:true)))),
+          #     s(:def, :foo,
+          #       s(:args),
+          #       s(:send, nil, :bar)))
+          #
+          # @param node [Parser::AST::Node]
+          def match?(node)
+            return false unless node&.type == :class
+
+            data_definition_node?(node.children[1])
+          end
+
+          private
+
+          # @param data_node [Parser::AST::Node]
+          # @return [Boolean]
+          def data_definition_node?(data_node)
+            return false unless data_node.is_a?(::Parser::AST::Node)
+            return false unless data_node&.type == :send
+            return false unless data_node.children[0]&.type == :const
+            return false unless data_node.children[0].children[1] == :Data
+            return false unless data_node.children[1] == :define
+
+            true
+          end
+        end
+
+        # @param node [Parser::AST::Node]
+        def initialize(node)
+          @node = node
+        end
+
+        # @return [String]
+        def class_name
+          Parser::NodeMethods.unpack_name(node)
+        end
+
+        # @return [Array<Array(Parser::AST::Node, String)>]
+        def attributes
+          data_attribute_nodes.map do |data_def_param|
+            next unless data_def_param.type == :sym
+            [data_def_param, data_def_param.children[0].to_s]
+          end.compact
+        end
+
+        # @return [Parser::AST::Node]
+        def body_node
+          node.children[2]
+        end
+
+        private
+
+        # @return [Parser::AST::Node]
+        attr_reader :node
+
+        # @return [Parser::AST::Node]
+        def data_node
+          node.children[1]
+        end
+
+        # @return [Array<Parser::AST::Node>]
+        def data_attribute_nodes
+          data_node.children[2..-1]
+        end
+      end
+    end
+  end
+end