solargraph 0.54.0 → 0.55.0

data/lib/solargraph/complex_type/unique_type.rb

@@ -7,9 +7,15 @@ module Solargraph
     #
     class UniqueType
       include TypeMethods
+      include Equality
 
       attr_reader :all_params, :subtypes, :key_types
 
+      # @sg-ignore Fix "Not enough arguments to Module#protected"
+      protected def equality_fields
+        [@name, @all_params, @subtypes, @key_types]
+      end
+
       # Create a UniqueType with the specified name and an optional substring.
       # The substring is the parameter section of a parametrized type, e.g.,
       # for the type `Array<String>`, the name is `Array` and the substring is
@@ -21,11 +27,13 @@ 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]
           rooted = true
+        elsif !can_root_name?(name)
+          rooted = true
         else
           rooted = false
         end
@@ -40,7 +48,7 @@ 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)
+            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)
             # @todo should be able to resolve map; both types have it
             #   with same return type
             # @sg-ignore
@@ -63,21 +71,83 @@ module Solargraph
         if parameters_type.nil?
           raise "You must supply parameters_type if you provide parameters" unless key_types.empty? && subtypes.empty?
         end
-        raise "Please remove leading :: and set rooted instead - #{name}" if name.start_with?('::')
+        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
 
+      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
+
+      def non_literal_name
+        @non_literal_name ||= determine_non_literal_name
+      end
+
+      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 &&
+          @key_types == other.key_types &&
+          @subtypes == other.subtypes &&
+          @rooted == other.rooted? &&
+          @all_params == other.all_params &&
+          @parameters_type == other.parameters_type
+      end
+
+      def ==(other)
+        eql?(other)
+      end
+
+      def hash
+        [self.class, @name, @key_types, @sub_types, @rooted, @all_params, @parameters_type].hash
+      end
+
       # @return [Array<UniqueType>]
       def items
         [self]
@@ -87,11 +157,17 @@ module Solargraph
       def rbs_name
         if name == 'undefined'
           'untyped'
+        elsif literal?
+          name
         else
           rooted_name
         end
       end
 
+      def desc
+        rooted_tags
+      end
+
       # @return [String]
       def to_rbs
         if duck_type?
@@ -108,7 +184,11 @@ module Solargraph
           # tuples don't have a name; they're just [foo, bar, baz].
           if substring == '()'
             # but there are no zero element tuples, so we go with an array
-            'Array[]'
+            if rooted?
+              '::Array[]'
+            else
+              'Array[]'
+            end
           else
             # already generated surrounded by []
             parameters_as_rbs
@@ -149,6 +229,23 @@ 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
@@ -211,7 +308,23 @@ module Solargraph
           if t.name == GENERIC_TAG_NAME
             idx = definitions.generics.index(t.subtypes.first&.name)
             next t if idx.nil?
-            context_type.all_params[idx] || ComplexType::UNDEFINED
+            if context_type.parameters_type == :hash
+              if idx == 0
+                next ComplexType.new(context_type.key_types)
+              elsif idx == 1
+                next ComplexType.new(context_type.subtypes)
+              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
+            end
           else
             t
           end
@@ -238,6 +351,7 @@ module Solargraph
       # @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?('::')
+
         new_name ||= name
         new_key_types ||= @key_types
         new_subtypes ||= @subtypes
@@ -278,17 +392,26 @@ module Solargraph
           new_key_types = @key_types.flat_map { |ct| ct.items.map { |ut| ut.transform(&transform_type) } }
           new_subtypes = @subtypes.flat_map { |ct| ct.items.map { |ut| ut.transform(&transform_type) } }
         end
-        new_type = recreate(new_name: new_name || name, new_key_types: new_key_types, new_subtypes: new_subtypes)
+        new_type = recreate(new_name: new_name || name, new_key_types: new_key_types, new_subtypes: new_subtypes, make_rooted: @rooted)
         yield new_type
       end
 
-      # Transform references to the 'self' type to the specified concrete namespace
-      # @param dst [String]
-      # @return [UniqueType]
-      def self_to dst
+      # Generate a ComplexType that fully qualifies this type's namespaces.
+      #
+      # @param api_map [ApiMap] The ApiMap that performs qualification
+      # @param context [String] The namespace from which to resolve names
+      # @return [self, ComplexType, UniqueType] The generated ComplexType
+      def qualify api_map, context = ''
         transform do |t|
-          next t if t.name != 'self'
-          t.recreate(new_name: dst, new_key_types: [], new_subtypes: [])
+          next t if t.name == GENERIC_TAG_NAME
+          next t if t.duck_type? || t.void? || t.undefined?
+          recon = (t.rooted? ? '' : context)
+          fqns = api_map.qualify(t.name, recon)
+          if fqns.nil?
+            next UniqueType::BOOLEAN if t.tag == 'Boolean'
+            next UniqueType::UNDEFINED
+          end
+          t.recreate(new_name: fqns, make_rooted: true)
         end
       end
 
@@ -296,8 +419,49 @@ module Solargraph
         @name == 'self' || @key_types.any?(&:selfy?) || @subtypes.any?(&:selfy?)
       end
 
+      # @param dst [ComplexType]
+      # @return [self]
+      def self_to_type dst
+        object_type_dst = dst.reduce_class_type
+        transform do |t|
+          next t if t.name != 'self'
+          object_type_dst
+        end
+      end
+
+      def all_rooted?
+        return true if name == GENERIC_TAG_NAME
+        rooted? && all_params.all?(&:rooted?)
+      end
+
+      def rooted?
+        !can_root_name? || @rooted
+      end
+
+      def can_root_name?(name_to_check = name)
+        self.class.can_root_name?(name_to_check)
+      end
+
+      # @param name [String]
+      def self.can_root_name?(name)
+        # name is not lowercase
+        !name.empty? && name != name.downcase
+      end
+
       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

@@ -7,6 +7,7 @@ module Solargraph
     GENERIC_TAG_NAME = 'generic'.freeze
     # @!parse
     #   include TypeMethods
+    include Equality
 
     autoload :TypeMethods, 'solargraph/complex_type/type_methods'
     autoload :UniqueType,  'solargraph/complex_type/unique_type'
@@ -15,7 +16,18 @@ 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"
+    protected def equality_fields
+      [self.class, items]
     end
 
     # @param api_map [ApiMap]
@@ -24,7 +36,8 @@ module Solargraph
     def qualify api_map, context = ''
       red = reduce_object
       types = red.items.map do |t|
-        next t if ['Boolean', 'nil', 'void', 'undefined'].include?(t.name)
+        next t if ['nil', 'void', 'undefined'].include?(t.name)
+        next t if ['::Boolean'].include?(t.rooted_name)
         t.qualify api_map, context
       end
       ComplexType.new(types).reduce_object
@@ -52,8 +65,18 @@ module Solargraph
        (@items.length > 1 ? ')' : ''))
     end
 
+    # @param dst [ComplexType]
+    # @return [ComplexType]
+    def self_to_type dst
+      object_type_dst = dst.reduce_class_type
+      transform do |t|
+        next t if t.name != 'self'
+        object_type_dst
+      end
+    end
+
     # @yieldparam [UniqueType]
-    # @return [Array]
+    # @return [Array<UniqueType>]
     def map &block
       @items.map &block
     end
@@ -76,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
@@ -86,10 +115,6 @@ module Solargraph
       @items
     end
 
-    def tags
-      @items.map(&:tag).join(', ')
-    end
-
     # @param index [Integer]
     # @return [UniqueType]
     def [](index)
@@ -130,14 +155,39 @@ 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
+
     def rooted_tags
       map(&:rooted_tag).join(', ')
     end
 
+    # @yieldparam [UniqueType]
     def all? &block
       @items.all? &block
     end
 
+    # @yieldparam [UniqueType]
+    # @yieldreturn [Boolean]
+    # @return [Boolean]
     def any? &block
       @items.compact.any? &block
     end
@@ -150,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]
@@ -171,16 +225,7 @@ module Solargraph
     # @return [ComplexType]
     def resolve_generics definitions, context_type
       result = @items.map { |i| i.resolve_generics(definitions, context_type) }
-      ComplexType.try_parse(*result.map(&:tag))
-    end
-
-    # @param dst [String]
-    # @return [ComplexType]
-    def self_to dst
-      return self unless selfy?
-      red = reduce_class(dst)
-      result = @items.map { |i| i.self_to red }
-      ComplexType.try_parse(*result.map(&:tag))
+      ComplexType.new(result)
     end
 
     def nullable?
@@ -192,14 +237,43 @@ module Solargraph
       @items.first.all_params || []
     end
 
+    # @return [ComplexType]
+    def reduce_class_type
+      new_items = items.flat_map do |type|
+        next type unless ['Module', 'Class'].include?(type.name)
+
+        type.all_params
+      end
+      ComplexType.new(new_items)
+    end
+
+    # every type and subtype in this union have been resolved to be
+    # fully qualified
+    def all_rooted?
+      all?(&:all_rooted?)
+    end
+
+    # every top-level type has resolved to be fully qualified; see
+    # #all_rooted? to check their subtypes as well
+    def rooted?
+      all?(&:rooted?)
+    end
+
     attr_reader :items
 
+    def rooted?
+      @items.all?(&:rooted?)
+    end
+
     protected
 
     # @return [ComplexType]
     def reduce_object
-      return self if name != 'Object' || subtypes.empty?
-      ComplexType.try_parse(reduce_class(subtypes.join(', ')))
+      new_items = items.flat_map do |ut|
+        next [ut] if ut.name != 'Object' || ut.subtypes.empty?
+        ut.subtypes
+      end
+      ComplexType.new(new_items)
     end
 
     def bottom?
@@ -219,12 +293,17 @@ module Solargraph
       #   Consumers should not need to use this parameter; it should only be
       #   used internally.
       #
-      # @param *strings [Array<String>] The type definitions to parse
+      # @param strings [Array<String>] The type definitions to parse
       # @return [ComplexType]
-      # @overload parse(*strings, partial: false)
-      #  @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>]
+      # # @overload parse(*strings, partial: false)
+      # #  @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
+      #   an array of Chains as the arguments.
       def parse *strings, partial: false
         # @type [Hash{Array<String> => ComplexType}]
         @cache ||= {}

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

@@ -0,0 +1,51 @@
+# 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 valid?(node)
+            return false unless node&.type == :casgn
+            return false if node.children[2].nil?
+            struct_node = node.children[2].children[0]
+
+            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
+          node.children[2].children[0]
+        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 valid?(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