solargraph 0.54.4 → 0.56.2

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,6 +155,23 @@ module Solargraph
       map(&:tag).join(', ')
     end
 
+    def tags
+      map(&:tag).join(', ')
+    end
+
+    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
+
     def desc
       rooted_tags
     end
@@ -175,6 +200,10 @@ module Solargraph
       any?(&:generic?)
     end
 
+    def simplify_literals
+      ComplexType.new(map(&:simplify_literals))
+    end
+
     # @param new_name [String, nil]
     # @yieldparam t [UniqueType]
     # @yieldreturn [UniqueType]

data/lib/solargraph/convention/base.rb

@@ -20,12 +20,12 @@ 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
     end

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

@@ -0,0 +1,60 @@
+# 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))))
+          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,89 @@
+# 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)))
+          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
+
+        # @return [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

data/lib/solargraph/convention/data_definition.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Convention
+    module DataDefinition
+      autoload :DataDefintionNode, 'solargraph/convention/data_definition/data_definition_node'
+      autoload :DataAssignmentNode, 'solargraph/convention/data_definition/data_assignment_node'
+
+      module NodeProcessors
+        class DataNode < Parser::NodeProcessor::Base
+          # @return [Boolean] continue processing the next processor of the same node.
+          def process
+            return true if data_definition_node.nil?
+
+            loc = get_node_location(node)
+            nspin = Solargraph::Pin::Namespace.new(
+              type: :class,
+              location: loc,
+              closure: region.closure,
+              name: data_definition_node.class_name,
+              comments: comments_for(node),
+              visibility: :public,
+              gates: region.closure.gates.freeze
+            )
+            pins.push nspin
+
+            # define initialize method
+            initialize_method_pin = Pin::Method.new(
+              name: 'initialize',
+              parameters: [],
+              scope: :instance,
+              location: get_node_location(node),
+              closure: nspin,
+              visibility: :private,
+              comments: comments_for(node)
+            )
+
+            # TODO: Support both arg and kwarg initializers for Data.define
+            # Solargraph::SourceMap::Clip#complete_keyword_parameters does not seem to currently take into account [Pin::Method#signatures] hence we only one for :kwarg
+            pins.push initialize_method_pin
+
+            data_definition_node.attributes.map do |attribute_node, attribute_name|
+              initialize_method_pin.parameters.push(
+                Pin::Parameter.new(
+                  name: attribute_name,
+                  decl: :kwarg,
+                  location: get_node_location(attribute_node),
+                  closure: initialize_method_pin
+                )
+              )
+            end
+
+            # define attribute readers and instance variables
+            data_definition_node.attributes.each do |attribute_node, attribute_name|
+              name = attribute_name.to_s
+              method_pin = Pin::Method.new(
+                name: name,
+                parameters: [],
+                scope: :instance,
+                location: get_node_location(attribute_node),
+                closure: nspin,
+                comments: attribute_comments(attribute_node, attribute_name),
+                visibility: :public
+              )
+
+              pins.push method_pin
+
+              pins.push Pin::InstanceVariable.new(name: "@#{attribute_name}",
+                                                  closure: method_pin,
+                                                  location: get_node_location(attribute_node),
+                                                  comments: attribute_comments(attribute_node, attribute_name))
+            end
+
+            process_children region.update(closure: nspin, visibility: :public)
+
+            false
+          end
+
+          private
+
+          # @return [DataDefintionNode, nil]
+          def data_definition_node
+            @data_definition_node ||= if DataDefintionNode.match?(node)
+                                        DataDefintionNode.new(node)
+                                      elsif DataAssignmentNode.match?(node)
+                                        DataAssignmentNode.new(node)
+                                      end
+          end
+
+          # @param attribute_node [Parser::AST::Node]
+          # @return [String, nil]
+          def attribute_comments(attribute_node, attribute_name)
+            data_comments = comments_for(attribute_node)
+            return if data_comments.nil? || data_comments.empty?
+
+            data_comments.split("\n").find do |row|
+              row.include?(attribute_name)
+            end&.gsub('@param', '@return')&.gsub(attribute_name, '')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/convention/gemspec.rb

@@ -12,7 +12,8 @@ module Solargraph
               'Gem::Specification.new',
               %(
 @yieldparam [self]
-              )
+              ),
+              source: :gemspec
             )
           ]
         )

data/lib/solargraph/convention/struct_definition/struct_assignment_node.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Convention
+    module StructDefinition
+      # A node wrapper for a Struct definition via const assignment.
+      # @example
+      #   MyStruct = Struct.new(:bar, :baz) do
+      #     def foo
+      #     end
+      #   end
+      class StructAssignmentNode < StructDefintionNode
+        class << self
+          # @example
+          # s(:casgn, nil, :Foo,
+          #   s(:block,
+          #     s(:send,
+          #       s(:const, nil, :Struct), :new,
+          #       s(:sym, :bar),
+          #       s(:sym, :baz)),
+          #     s(:args),
+          #     s(:def, :foo,
+          #       s(:args),
+          #       s(:send, nil, :bar))))
+          def match?(node)
+            return false unless node&.type == :casgn
+            return false if node.children[2].nil?
+
+            struct_node = if node.children[2].type == :block
+                            node.children[2].children[0]
+                          else
+                            node.children[2]
+                          end
+
+            struct_definition_node?(struct_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 struct_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/struct_definition/struct_definition_node.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Convention
+    module StructDefinition
+      # A node wrapper for a Struct definition via inheritance.
+      # @example
+      #   class MyStruct < Struct.new(:bar, :baz)
+      #     def foo
+      #     end
+      #   end
+      class StructDefintionNode
+        class << self
+          # @example
+          #   s(:class,
+          #     s(:const, nil, :Foo),
+          #     s(:send,
+          #       s(:const, nil, :Struct), :new,
+          #       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)))
+          def match?(node)
+            return false unless node&.type == :class
+
+            struct_definition_node?(node.children[1])
+          end
+
+          private
+
+          # @param struct_node [Parser::AST::Node]
+          # @return [Boolean]
+          def struct_definition_node?(struct_node)
+            return false unless struct_node.is_a?(::Parser::AST::Node)
+            return false unless struct_node&.type == :send
+            return false unless struct_node.children[0]&.type == :const
+            return false unless struct_node.children[0].children[1] == :Struct
+            return false unless struct_node.children[1] == :new
+
+            true
+          end
+        end
+
+        # @return [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
+          struct_attribute_nodes.map do |struct_def_param|
+            next unless struct_def_param.type == :sym
+            [struct_def_param, struct_def_param.children[0].to_s]
+          end.compact
+        end
+
+        def keyword_init?
+          keyword_init_param = struct_attribute_nodes.find do |struct_def_param|
+            struct_def_param.type == :hash && struct_def_param.children[0].type == :pair &&
+              struct_def_param.children[0].children[0].children[0] == :keyword_init
+          end
+
+          return false if keyword_init_param.nil?
+
+          keyword_init_param.children[0].children[1].type == :true
+        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 struct_node
+          node.children[1]
+        end
+
+        # @return [Array<Parser::AST::Node>]
+        def struct_attribute_nodes
+          struct_node.children[2..-1]
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/convention/struct_definition.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Convention
+    module StructDefinition
+      autoload :StructDefintionNode, 'solargraph/convention/struct_definition/struct_definition_node'
+      autoload :StructAssignmentNode, 'solargraph/convention/struct_definition/struct_assignment_node'
+
+      module NodeProcessors
+        class StructNode < Parser::NodeProcessor::Base
+          # @return [Boolean] continue processing the next processor of the same node.
+          def process
+            return true if struct_definition_node.nil?
+
+            loc = get_node_location(node)
+            nspin = Solargraph::Pin::Namespace.new(
+              type: :class,
+              location: loc,
+              closure: region.closure,
+              name: struct_definition_node.class_name,
+              docstring: docstring,
+              visibility: :public,
+              gates: region.closure.gates.freeze
+            )
+            pins.push nspin
+
+            # define initialize method
+            initialize_method_pin = Pin::Method.new(
+              name: 'initialize',
+              parameters: [],
+              scope: :instance,
+              location: get_node_location(node),
+              closure: nspin,
+              visibility: :private,
+              docstring: docstring
+            )
+
+            pins.push initialize_method_pin
+
+            struct_definition_node.attributes.map do |attribute_node, attribute_name|
+              initialize_method_pin.parameters.push(
+                Pin::Parameter.new(
+                  name: attribute_name,
+                  decl: struct_definition_node.keyword_init? ? :kwarg : :arg,
+                  location: get_node_location(attribute_node),
+                  closure: initialize_method_pin
+                )
+              )
+            end
+
+            # define attribute accessors and instance variables
+            struct_definition_node.attributes.each do |attribute_node, attribute_name|
+              [attribute_name, "#{attribute_name}="].each do |name|
+                docs = docstring.tags.find { |t| t.tag_name == 'param' && t.name == attribute_name }
+
+                method_pin = Pin::Method.new(
+                  name: name,
+                  parameters: [],
+                  scope: :instance,
+                  location: get_node_location(attribute_node),
+                  closure: nspin,
+                  # even assignments return the value
+                  comments: attribute_comment(docs, false),
+                  visibility: :public
+                )
+
+                if name.end_with?('=')
+                  method_pin.parameters << Pin::Parameter.new(
+                    name: attribute_name,
+                    location: get_node_location(attribute_node),
+                    closure: nspin,
+                    comments: attribute_comment(docs, true)
+                  )
+
+                  pins.push Pin::InstanceVariable.new(name: "@#{attribute_name}",
+                                    closure: method_pin,
+                                    location: get_node_location(attribute_node),
+                                    comments: attribute_comment(docs, false))
+                end
+
+                pins.push method_pin
+              end
+            end
+
+            process_children region.update(closure: nspin, visibility: :public)
+            false
+          end
+
+          private
+
+          # @return [StructDefintionNode, nil]
+          def struct_definition_node
+            @struct_definition_node ||= if StructDefintionNode.match?(node)
+                                          StructDefintionNode.new(node)
+                                        elsif StructAssignmentNode.match?(node)
+                                          StructAssignmentNode.new(node)
+                                        end
+          end
+
+          # Gets/generates the relevant docstring for this struct & it's attributes
+          # @return [YARD::Docstring]
+          def docstring
+            @docstring ||= parse_comments
+          end
+
+          # Parses any relevant comments for a struct int a yard docstring
+          # @return [YARD::Docstring]
+          def parse_comments
+            struct_comments = comments_for(node) || ''
+            struct_definition_node.attributes.each do |attr_node, attr_name|
+              comment = comments_for(attr_node)
+              next if comment.nil?
+
+              # We should support specific comments for an attribute, and that can be either a @return on an @param
+              # But since we merge into the struct_comments, then we should interpret either as a param
+              comment = '@param ' + attr_name + comment[7..] if comment.start_with?('@return')
+
+              struct_comments += "\n#{comment}"
+            end
+
+            Solargraph::Source.parse_docstring(struct_comments).to_docstring
+          end
+
+          # @param tag [YARD::Tags::Tag, nil] The param tag for this attribute. If nil, this method is a no-op
+          # @param for_setter [Boolean] If true, will return a @param tag instead of a @return tag
+          def attribute_comment(tag, for_setter)
+            return "" if tag.nil?
+
+            suffix = "[#{tag.types&.join(',') || 'undefined'}] #{tag.text}"
+
+            if for_setter
+              "@param #{tag.name} #{suffix}"
+            else
+              "@return #{suffix}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/convention.rb

@@ -10,6 +10,8 @@ module Solargraph
     autoload :Gemfile, 'solargraph/convention/gemfile'
     autoload :Gemspec, 'solargraph/convention/gemspec'
     autoload :Rakefile, 'solargraph/convention/rakefile'
+    autoload :StructDefinition, 'solargraph/convention/struct_definition'
+    autoload :DataDefinition,   'solargraph/convention/data_definition'
 
     # @type [Set<Convention::Base>]
     @@conventions = Set.new
@@ -30,12 +32,12 @@ module Solargraph
       result
     end
 
-    # @param yard_map [YardMap]
+    # @param yard_map [DocMap]
     # @return [Environ]
-    def self.for_global(yard_map)
+    def self.for_global(doc_map)
       result = Environ.new
       @@conventions.each do |conv|
-        result.merge conv.global(yard_map)
+        result.merge conv.global(doc_map)
       end
       result
     end