solargraph 0.59.0.dev.1 → 0.59.0.dev.2

data/lib/solargraph/bench.rb

@@ -1,45 +1,44 @@
-# frozen_string_literal: true
-
-
-module Solargraph
-  # A container of source maps and workspace data to be cataloged in an ApiMap.
-  #
-  class Bench
-    # @return [Set<SourceMap>]
-    attr_reader :source_maps
-
-    # @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, 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
+# frozen_string_literal: true
+
+module Solargraph
+  # A container of source maps and workspace data to be cataloged in an ApiMap.
+  #
+  class Bench
+    # @return [Set<SourceMap>]
+    attr_reader :source_maps
+
+    # @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, 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
+
+    # @sg-ignore flow sensitive typing needs better handling of ||= on lvars
+    # @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.to_h { |s| [s.filename, s] }
+    end
+
+    # @return [Set<SourceMap>]
+    def icebox
+      @icebox ||= (source_maps - [live_map])
+    end
+  end
+end

data/lib/solargraph/complex_type/type_methods.rb

@@ -54,11 +54,11 @@ module Solargraph
 
       # @return [Boolean]
       def nil_type?
-        @nil_type ||= (name.casecmp('nil') == 0)
+        @nil_type ||= name.casecmp('nil').zero?
       end
 
       def tuple?
-        @tuple_type ||= (name == 'Tuple') || (name == 'Array' && subtypes.length >= 1 && fixed_parameters?)
+        @tuple ||= (name == 'Tuple') || (name == 'Array' && subtypes.length >= 1 && fixed_parameters?)
       end
 
       def void?
@@ -87,7 +87,7 @@ module Solargraph
 
       # @param generics_to_erase [Enumerable<String>]
       # @return [self]
-      def erase_generics(generics_to_erase)
+      def erase_generics generics_to_erase
         transform do |type|
           if type.name == ComplexType::GENERIC_TAG_NAME
             if type.all_params.length == 1 && generics_to_erase.include?(type.all_params.first.to_s)
@@ -142,7 +142,7 @@ module Solargraph
         @namespace ||= lambda do
           return 'Object' if duck_type?
           return 'NilClass' if nil_type?
-          return (name == 'Class' || name == 'Module') && !subtypes.empty? ? subtypes.first.name : name
+          %w[Class Module].include?(name) && !subtypes.empty? ? subtypes.first.name : name
         end.call
       end
 
@@ -150,7 +150,7 @@ module Solargraph
       def namespace_type
         return ComplexType.parse('::Object') if duck_type?
         return ComplexType.parse('::NilClass') if nil_type?
-        return subtypes.first if (name == 'Class' || name == 'Module') && !subtypes.empty?
+        return subtypes.first if %w[Class Module].include?(name) && !subtypes.empty?
         self
       end
 
@@ -177,30 +177,27 @@ module Solargraph
       end
 
       # @return [String]
-      def generate_substring_from(&to_str)
+      def generate_substring_from &to_str
         key_types_str = key_types.map(&to_str).join(', ')
         subtypes_str = subtypes.map(&to_str).join(', ')
-        if key_types.none?(&:defined?) && subtypes.none?(&:defined?)
-          ''
-        elsif key_types.empty? && subtypes.empty?
+        if (key_types.none?(&:defined?) && subtypes.none?(&:defined?)) ||
+           (key_types.empty? && subtypes.empty?)
           ''
         elsif hash_parameters?
           "{#{key_types_str} => #{subtypes_str}}"
         elsif fixed_parameters?
           "(#{subtypes_str})"
+        elsif name == 'Hash'
+          "<#{key_types_str}, #{subtypes_str}>"
         else
-          if name == 'Hash'
-            "<#{key_types_str}, #{subtypes_str}>"
-          else
-            "<#{key_types_str}#{subtypes_str}>"
-          end
+          "<#{key_types_str}#{subtypes_str}>"
         end
       end
 
       # @return [::Symbol] :class or :instance
       def scope
         @scope ||= :instance if duck_type? || nil_type?
-        @scope ||= (name == 'Class' || name == 'Module') && !subtypes.empty? ? :class : :instance
+        @scope ||= %w[Class Module].include?(name) && !subtypes.empty? ? :class : :instance
       end
 
       # @param other [Object]

data/lib/solargraph/complex_type/unique_type.rb

@@ -11,10 +11,6 @@ module Solargraph
 
       attr_reader :all_params, :subtypes, :key_types
 
-      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
@@ -25,11 +21,9 @@ module Solargraph
       # @param make_rooted [Boolean, nil]
       # @return [UniqueType]
       def self.parse name, substring = '', make_rooted: nil
-        if name.start_with?(':::')
-          raise ComplexTypeError, "Illegal prefix: #{name}"
-        end
+        raise ComplexTypeError, "Illegal prefix: #{name}" if name.start_with?(':::')
         if name.start_with?('::')
-          name = name[2..-1]
+          name = name[2..]
           rooted = true
         elsif !can_root_name?(name)
           rooted = true
@@ -48,13 +42,17 @@ module Solargraph
           # @sg-ignore Need to add nil check here
           parameters_type = PARAMETERS_TYPE_BY_STARTING_TAG.fetch(substring[0])
           if parameters_type == :hash
-            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)
+            unless !subs.is_a?(ComplexType) && (subs.length == 2) && !subs[0].is_a?(UniqueType) && !subs[1].is_a?(UniqueType)
+              raise ComplexTypeError,
+                    "Bad hash type: name=#{name}, substring=#{substring}"
+            end
             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"
+              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]) })
             subtypes.concat(subs[1].map { |u| ComplexType.new([u]) })
@@ -71,9 +69,9 @@ module Solargraph
       # @param subtypes [Array<ComplexType>]
       # @param rooted [Boolean]
       # @param parameters_type [Symbol, nil]
-      def initialize(name, key_types = [], subtypes = [], rooted:, parameters_type: nil)
-        if parameters_type.nil?
-          raise "You must supply parameters_type if you provide parameters" unless key_types.empty? && subtypes.empty?
+      def initialize name, key_types = [], subtypes = [], rooted:, parameters_type: nil
+        if parameters_type.nil? && !(key_types.empty? && subtypes.empty?)
+          raise 'You must supply parameters_type if you provide parameters'
         end
         raise "Please remove leading :: and set rooted instead - #{name.inspect}" if name.start_with?('::')
         @name = name
@@ -95,7 +93,7 @@ module Solargraph
         # @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
+        %w[Hash Array Set _ToAry Enumerable _Each].include?(name) && parameters_type != :fixed
       end
 
       def to_s
@@ -175,7 +173,7 @@ module Solargraph
         #    | `false`
         return name if name.empty?
         return 'NilClass' if name == 'nil'
-        return 'Boolean' if ['true', 'false'].include?(name)
+        return 'Boolean' if %w[true false].include?(name)
         return 'Symbol' if name[0] == ':'
         # @sg-ignore Need to add nil check here
         return 'String' if ['"', "'"].include?(name[0])
@@ -183,7 +181,7 @@ module Solargraph
         name
       end
 
-      def eql?(other)
+      def eql? other
         self.class == other.class &&
           # @sg-ignore flow sensitive typing should support .class == .class
           @name == other.name &&
@@ -199,7 +197,7 @@ module Solargraph
           @parameters_type == other.parameters_type
       end
 
-      def ==(other)
+      def == other
         eql?(other)
       end
 
@@ -231,7 +229,7 @@ module Solargraph
         #   covariant
         # contravariant?: Proc - can be changed, so we can pass
         #   in less specific super types
-        if ['Hash', 'Tuple', 'Array', 'Set', 'Enumerable'].include?(name) && fixed_parameters?
+        if %w[Hash Tuple Array Set Enumerable].include?(name) && fixed_parameters?
           :covariant
         else
           default
@@ -244,7 +242,7 @@ module Solargraph
       end
 
       # @param other [UniqueType]
-      def erased_version_of?(other)
+      def erased_version_of? other
         name == other.name && (all_params.empty? || all_params.all?(&:undefined?))
       end
 
@@ -253,8 +251,8 @@ module Solargraph
       # @param situation [:method_call, :assignment, :return_type]
       # @param rules [Array<:allow_subtype_skew, :allow_empty_params, :allow_reverse_match, :allow_any_match, :allow_undefined, :allow_unresolved_generic>]
       # @param variance [:invariant, :covariant, :contravariant]
-      def conforms_to?(api_map, expected, situation, rules = [],
-                       variance: erased_variance(situation))
+      def conforms_to? api_map, expected, situation, rules = [],
+                       variance: erased_variance(situation)
         return true if undefined? && rules.include?(:allow_undefined)
 
         # @todo teach this to validate duck types as inferred type
@@ -315,9 +313,9 @@ module Solargraph
           'nil'
         elsif name == GENERIC_TAG_NAME
           all_params.first&.name
-        elsif ['Class', 'Module'].include?(name)
+        elsif %w[Class Module].include?(name)
           rbs_name
-        elsif ['Tuple', 'Array'].include?(name) && fixed_parameters?
+        elsif %w[Tuple Array].include?(name) && fixed_parameters?
           # 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
@@ -342,7 +340,7 @@ module Solargraph
 
       # @param types [Array<UniqueType, ComplexType>]
       # @return [String]
-      def rbs_union(types)
+      def rbs_union types
         if types.length == 1
           types.first.to_rbs
         else
@@ -397,7 +395,8 @@ module Solargraph
           end
           if new_binding
             resolved_generic_values.transform_values! do |complex_type|
-              complex_type.resolve_generics_from_context(generics_to_resolve, nil, resolved_generic_values: resolved_generic_values)
+              complex_type.resolve_generics_from_context(generics_to_resolve, nil,
+                                                         resolved_generic_values: resolved_generic_values)
             end
           end
           # @sg-ignore flow sensitive typing needs to eliminate literal from union with [:bar].include?(foo)
@@ -405,8 +404,10 @@ module Solargraph
         end
 
         # @todo typechecking should complain when the method being called has no @yieldparam tag
-        new_key_types = resolve_param_generics_from_context(generics_to_resolve, context_type, resolved_generic_values, &:key_types)
-        new_subtypes = resolve_param_generics_from_context(generics_to_resolve, context_type, resolved_generic_values, &:subtypes)
+        new_key_types = resolve_param_generics_from_context(generics_to_resolve, context_type, resolved_generic_values,
+                                                            &:key_types)
+        new_subtypes = resolve_param_generics_from_context(generics_to_resolve, context_type, resolved_generic_values,
+                                                           &:subtypes)
         recreate(new_key_types: new_key_types, new_subtypes: new_subtypes)
       end
 
@@ -415,7 +416,7 @@ module Solargraph
       # @param resolved_generic_values [Hash{String => ComplexType}]
       # @yieldreturn [Array<ComplexType>]
       # @return [Array<ComplexType>]
-      def resolve_param_generics_from_context(generics_to_resolve, context_type, resolved_generic_values)
+      def resolve_param_generics_from_context generics_to_resolve, context_type, resolved_generic_values
         types = yield self
         types.each_with_index.flat_map do |ct, i|
           ct.items.flat_map do |ut|
@@ -423,10 +424,12 @@ module Solargraph
             if context_params && context_params[i]
               type_arg = context_params[i]
               type_arg.map do |new_unique_context_type|
-                ut.resolve_generics_from_context generics_to_resolve, new_unique_context_type, resolved_generic_values: resolved_generic_values
+                ut.resolve_generics_from_context generics_to_resolve, new_unique_context_type,
+                                                 resolved_generic_values: resolved_generic_values
               end
             else
-              ut.resolve_generics_from_context generics_to_resolve, nil, resolved_generic_values: resolved_generic_values
+              ut.resolve_generics_from_context generics_to_resolve, nil,
+                                               resolved_generic_values: resolved_generic_values
             end
           end
         end
@@ -448,7 +451,7 @@ module Solargraph
             idx = definitions.generics.index(generic_name)
             next t if idx.nil?
             if context_type.parameters_type == :hash
-              if idx == 0
+              if idx.zero?
                 next ComplexType.new(context_type.key_types)
               elsif idx == 1
                 next ComplexType.new(context_type.subtypes)
@@ -456,7 +459,7 @@ module Solargraph
                 next ComplexType::UNDEFINED
               end
             elsif context_type.all?(&:implicit_union?)
-              if idx == 0 && !context_type.all_params.empty?
+              if idx.zero? && !context_type.all_params.empty?
                 ComplexType.new(context_type.all_params)
               else
                 ComplexType::UNDEFINED
@@ -482,7 +485,7 @@ module Solargraph
       # @yieldreturn [self]
       # @return [Enumerable<self>]
       def each &block
-        [self].each &block
+        [self].each(&block)
       end
 
       # @return [Array<UniqueType>]
@@ -493,10 +496,10 @@ module Solargraph
       # @param new_name [String, nil]
       # @param make_rooted [Boolean, nil]
       # @param new_key_types [Array<ComplexType>, nil]
-      # @param rooted [Boolean, nil]
+      # @param make_rooted [Boolean, nil]
       # @param new_subtypes [Array<ComplexType>, nil]
       # @return [self]
-      def recreate(new_name: nil, make_rooted: nil, new_key_types: nil, new_subtypes: nil)
+      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
@@ -530,8 +533,10 @@ module Solargraph
       # @yieldparam t [UniqueType]
       # @yieldreturn [self]
       # @return [self]
-      def transform(new_name = nil, &transform_type)
-        raise "Please remove leading :: and set rooted with recreate() instead - #{new_name}" if new_name&.start_with?('::')
+      def transform new_name = nil, &transform_type
+        if new_name&.start_with?('::')
+          raise "Please remove leading :: and set rooted with recreate() instead - #{new_name}"
+        end
         if name == ComplexType::GENERIC_TAG_NAME
           # doesn't make sense to manipulate the name of the generic
           new_key_types = @key_types
@@ -540,14 +545,15 @@ 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, make_rooted: @rooted)
+        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
 
       # 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
+      # @param gates [Array<String>] The namespaces from which to resolve names
       # @return [self, ComplexType, UniqueType] The generated ComplexType
       def qualify api_map, *gates
         transform do |t|
@@ -585,7 +591,7 @@ module Solargraph
       # @return [ComplexType]
       def reduce_class_type
         new_items = items.flat_map do |type|
-          next type unless ['Module', 'Class'].include?(type.name)
+          next type unless %w[Module Class].include?(type.name)
           next type if type.all_params.empty?
 
           type.all_params
@@ -603,12 +609,12 @@ module Solargraph
       end
 
       # @param name_to_check [String]
-      def can_root_name?(name_to_check = name)
+      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)
+      def self.can_root_name? name
         # name is not lowercase
         !name.empty? && name != name.downcase
       end
@@ -625,8 +631,13 @@ module Solargraph
         '::NilClass' => UniqueType::NIL
       }.freeze
 
-
       include Logging
+
+      protected
+
+      def equality_fields
+        [@name, @all_params, @subtypes, @key_types]
+      end
     end
   end
 end