solargraph 0.59.0.dev.1 → 0.59.0

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,15 +173,14 @@ 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])
         return 'Integer' if name.match?(/^-?\d+$/)
         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 +196,7 @@ module Solargraph
           @parameters_type == other.parameters_type
       end
 
-      def ==(other)
+      def == other
         eql?(other)
       end
 
@@ -231,20 +228,20 @@ 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
         end
       end
 
-      # Whether this is an RBS interface like _ToAry or _Each.
+      # Whether this is an RBS interface like _ToAry or Hash::_Key.
       def interface?
-        name.start_with?('_')
+        name.start_with?('_') || name.include?('::_')
       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 +250,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 +312,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 +339,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
@@ -387,7 +384,6 @@ module Solargraph
       def resolve_generics_from_context generics_to_resolve, context_type, resolved_generic_values: {}
         if name == ComplexType::GENERIC_TAG_NAME
           type_param = subtypes.first&.name
-          # @sg-ignore flow sensitive typing needs to eliminate literal from union with [:bar].include?(foo)
           return self unless generics_to_resolve.include? type_param
           # @sg-ignore flow sensitive typing needs to eliminate literal from union with [:bar].include?(foo)
           unless context_type.nil? || !resolved_generic_values[type_param].nil?
@@ -397,7 +393,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 +402,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 +414,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 +422,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 +449,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 +457,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 +483,7 @@ module Solargraph
       # @yieldreturn [self]
       # @return [Enumerable<self>]
       def each &block
-        [self].each &block
+        [self].each(&block)
       end
 
       # @return [Array<UniqueType>]
@@ -493,10 +494,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 +531,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 +543,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 +589,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 +607,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 +629,13 @@ module Solargraph
         '::NilClass' => UniqueType::NIL
       }.freeze
 
-
       include Logging
+
+      protected
+
+      def equality_fields
+        [@name, @all_params, @subtypes, @key_types]
+      end
     end
   end
 end

data/lib/solargraph/complex_type.rb

@@ -4,7 +4,7 @@ module Solargraph
   # A container for type data based on YARD type tags.
   #
   class ComplexType
-    GENERIC_TAG_NAME = 'generic'.freeze
+    GENERIC_TAG_NAME = 'generic'
     # @!parse
     #   include TypeMethods
     include Equality
@@ -19,7 +19,7 @@ module Solargraph
       # @type [Array<UniqueType>]
       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.delete_if { |i| %w[false true].include?(i.name) }
         items.unshift(UniqueType::BOOLEAN)
       end
       # @type [Array<UniqueType>]
@@ -29,19 +29,16 @@ module Solargraph
       @items = items
     end
 
-    protected def equality_fields
-      [self.class, items]
-    end
-
     # @param api_map [ApiMap]
-    # @param context [String]
+    # @param gates [Array<String>]
+    #
     # @return [ComplexType]
     def qualify api_map, *gates
       red = reduce_object
       types = red.items.map do |t|
-        next t if ['nil', 'void', 'undefined'].include?(t.name)
+        next t if %w[nil void undefined].include?(t.name)
         next t if ['::Boolean'].include?(t.rooted_name)
-        t.qualify api_map, *gates
+        api_map.unalias(t.name) || t.qualify(api_map, *gates)
       end
       ComplexType.new(types).reduce_object
     end
@@ -53,7 +50,10 @@ module Solargraph
     def resolve_generics_from_context generics_to_resolve, context_type, resolved_generic_values: {}
       return self unless generic?
 
-      ComplexType.new(@items.map { |i| i.resolve_generics_from_context(generics_to_resolve, context_type, resolved_generic_values: resolved_generic_values) })
+      ComplexType.new(@items.map do |i|
+        i.resolve_generics_from_context(generics_to_resolve, context_type,
+                                        resolved_generic_values: resolved_generic_values)
+      end)
     end
 
     # @return [UniqueType]
@@ -84,14 +84,14 @@ module Solargraph
     # @sg-ignore Declared return type
     #   ::Array<::Solargraph::ComplexType::UniqueType> does not match
     #   inferred type ::Array<::Proc> for Solargraph::ComplexType#map
-    def map(&block)
+    def map &block
       @items.map(&block)
     end
 
     # @yieldparam [UniqueType]
     # @return [Enumerable<UniqueType>]
     def each &block
-      @items.each &block
+      @items.each(&block)
     end
 
     # @yieldparam [UniqueType]
@@ -102,17 +102,17 @@ module Solargraph
       return enum_for(__method__) unless block_given?
 
       @items.each do |item|
-        item.each_unique_type &block
+        item.each_unique_type(&block)
       end
     end
 
     # @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
       ComplexType.new(map do |ut|
                         ut.recreate(new_name: new_name,
                                     make_rooted: make_rooted,
@@ -133,13 +133,13 @@ module Solargraph
 
     # @param index [Integer]
     # @return [UniqueType]
-    def [](index)
+    def [] index
       @items[index]
     end
 
     # @return [Array<UniqueType>]
     def select &block
-      @items.select &block
+      @items.select(&block)
     end
 
     # @return [String]
@@ -154,7 +154,9 @@ module Solargraph
     end
 
     # @param name [Symbol]
+    #
     # @return [Object, nil]
+    # @param [Array<Object>] args
     def method_missing name, *args, &block
       return if @items.first.nil?
       return @items.first.send(name, *args, &block) if respond_to_missing?(name)
@@ -163,7 +165,7 @@ module Solargraph
 
     # @param name [Symbol]
     # @param include_private [Boolean]
-    def respond_to_missing?(name, include_private = false)
+    def respond_to_missing? name, include_private = false
       TypeMethods.public_instance_methods.include?(name) || super
     end
 
@@ -198,24 +200,29 @@ module Solargraph
     # @param api_map [ApiMap]
     # @param expected [ComplexType, ComplexType::UniqueType]
     # @param situation [:method_call, :return_type, :assignment]
-    # @param allow_subtype_skew [Boolean] if false, check if any
-    #   subtypes of the expected type match the inferred type
-    # @param allow_reverse_match [Boolean] if true, check if any subtypes
-    #   of the expected type match the inferred type
-    # @param allow_empty_params [Boolean] if true, allow a general
-    #   inferred type without parameters to conform to a more specific
-    #   expected type
-    # @param allow_any_match [Boolean] if true, any unique type
-    #   matched in the inferred qualifies as a match
-    # @param allow_undefined [Boolean] if true, treat undefined as a
-    #   wildcard that matches anything
     # @param rules [Array<:allow_subtype_skew, :allow_empty_params, :allow_reverse_match, :allow_any_match, :allow_undefined, :allow_unresolved_generic, :allow_unmatched_interface>]
+    #
+    #   allow_subtype_skew: if not provided, check if any subtypes of
+    #     the expected type match the inferred type
+    #
+    #   allow_reverse_match: check if any subtypes
+    #     of the expected type match the inferred type
+    #
+    #   allow_empty_params: allow a general inferred type without
+    #     parameters to conform to a more specific expected type
+    #
+    #   allow_any_match: any unique type matched in the inferred
+    #     qualifies as a match
+    #
+    #   allow_undefined: treat undefined as a wildcard that matches
+    #     anything
+    #
     # @param variance [:invariant, :covariant, :contravariant]
     # @return [Boolean]
-    def conforms_to?(api_map, expected,
+    def conforms_to? api_map, expected,
                      situation,
                      rules = [],
-                     variance: erased_variance(situation))
+                     variance: erased_variance(situation)
       expected = expected.downcast_to_literal_if_possible
       inferred = downcast_to_literal_if_possible
 
@@ -256,14 +263,14 @@ module Solargraph
 
     # @yieldparam [UniqueType]
     def all? &block
-      @items.all? &block
+      @items.all?(&block)
     end
 
     # @yieldparam [UniqueType]
     # @yieldreturn [Boolean]
     # @return [Boolean]
     def any? &block
-      @items.compact.any? &block
+      @items.compact.any?(&block)
     end
 
     def selfy?
@@ -283,8 +290,10 @@ module Solargraph
     # @yieldparam t [UniqueType]
     # @yieldreturn [UniqueType]
     # @return [ComplexType]
-    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
       ComplexType.new(map { |ut| ut.transform(new_name, &transform_type) })
     end
 
@@ -322,7 +331,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
@@ -337,7 +346,7 @@ module Solargraph
     end
 
     # @param other [ComplexType, UniqueType]
-    def erased_version_of?(other)
+    def erased_version_of? other
       return false if items.length != 1 || other.items.length != 1
 
       @items.first.erased_version_of?(other.items.first)
@@ -351,10 +360,6 @@ module Solargraph
 
     attr_reader :items
 
-    def rooted?
-      @items.all?(&:rooted?)
-    end
-
     # @param exclude_types [ComplexType, nil]
     # @param api_map [ApiMap]
     # @return [ComplexType, self]
@@ -391,6 +396,10 @@ module Solargraph
 
     protected
 
+    def equality_fields
+      [self.class, items]
+    end
+
     # @return [ComplexType]
     def reduce_object
       new_items = items.flat_map do |ut|
@@ -410,13 +419,11 @@ module Solargraph
       # @example
       #   ComplexType.parse 'String', 'Foo', 'nil' #=> [String, Foo, nil]
       #
-      # @note
-      #   The `partial` parameter is used to indicate that the method is
-      #   receiving a string that will be used inside another ComplexType.
-      #   It returns arrays of ComplexTypes instead of a single cohesive one.
-      #   Consumers should not need to use this parameter; it should only be
-      #   used internally.
-      #
+      # @param partial [Boolean] if true, method is receiving a string
+      #   that will be used inside another ComplexType.  It returns
+      #   arrays of ComplexTypes instead of a single cohesive one.
+      #   Consumers should not need to use this parameter; it should
+      #   only be used internally.
       # @param strings [Array<String>] The type definitions to parse
       # @return [ComplexType]
       # # @overload parse(*strings, partial: false)
@@ -446,14 +453,14 @@ module Solargraph
           # @param char [String]
           type_string&.each_char do |char|
             if char == '='
-              #raise ComplexTypeError, "Invalid = in type #{type_string}" unless curly_stack > 0
+              # raise ComplexTypeError, "Invalid = in type #{type_string}" unless curly_stack > 0
             elsif char == '<'
               point_stack += 1
             elsif char == '>'
-              if subtype_string.end_with?('=') && curly_stack > 0
+              if subtype_string.end_with?('=') && curly_stack.positive?
                 subtype_string += char
               elsif base.end_with?('=')
-                raise ComplexTypeError, "Invalid hash thing" unless key_types.nil?
+                raise ComplexTypeError, 'Invalid hash thing' unless key_types.nil?
                 # types.push ComplexType.new([UniqueType.new(base[0..-2].strip)])
                 # @sg-ignore Need to add nil check here
                 types.push UniqueType.parse(base[0..-2].strip, subtype_string)
@@ -466,7 +473,7 @@ module Solargraph
                 subtype_string.clear
                 next
               else
-                raise ComplexTypeError, "Invalid close in type #{type_string}" if point_stack == 0
+                raise ComplexTypeError, "Invalid close in type #{type_string}" if point_stack.zero?
                 point_stack -= 1
                 subtype_string += char
               end
@@ -476,34 +483,37 @@ module Solargraph
             elsif char == '}'
               curly_stack -= 1
               subtype_string += char
-              raise ComplexTypeError, "Invalid close in type #{type_string}" if curly_stack < 0
+              raise ComplexTypeError, "Invalid close in type #{type_string}" if curly_stack.negative?
               next
             elsif char == '('
               paren_stack += 1
             elsif char == ')'
               paren_stack -= 1
               subtype_string += char
-              raise ComplexTypeError, "Invalid close in type #{type_string}" if paren_stack < 0
+              raise ComplexTypeError, "Invalid close in type #{type_string}" if paren_stack.negative?
               next
-            elsif char == ',' && point_stack == 0 && curly_stack == 0 && paren_stack == 0
+            elsif char == ',' && point_stack.zero? && curly_stack.zero? && paren_stack.zero?
               # types.push ComplexType.new([UniqueType.new(base.strip, subtype_string.strip)])
               types.push UniqueType.parse(base.strip, subtype_string.strip)
               base.clear
               subtype_string.clear
               next
             end
-            if point_stack == 0 && curly_stack == 0 && paren_stack == 0
+            if point_stack.zero? && curly_stack.zero? && paren_stack.zero?
               base.concat char
             else
               subtype_string.concat char
             end
           end
-          raise ComplexTypeError, "Unclosed subtype in #{type_string}" if point_stack != 0 || curly_stack != 0 || paren_stack != 0
+          if point_stack != 0 || curly_stack != 0 || paren_stack != 0
+            raise ComplexTypeError,
+                  "Unclosed subtype in #{type_string}"
+          end
           # types.push ComplexType.new([UniqueType.new(base, subtype_string)])
           types.push UniqueType.parse(base.strip, subtype_string.strip)
         end
         unless key_types.nil?
-          raise ComplexTypeError, "Invalid use of key/value parameters" unless partial
+          raise ComplexTypeError, 'Invalid use of key/value parameters' unless partial
           return key_types if types.empty?
           return [key_types, types]
         end
@@ -515,7 +525,7 @@ module Solargraph
       # @param strings [Array<String>]
       # @return [ComplexType]
       def try_parse *strings
-        parse *strings
+        parse(*strings)
       rescue ComplexTypeError => e
         Solargraph.logger.info "Error parsing complex type `#{strings.join(', ')}`: #{e.message}"
         ComplexType::UNDEFINED
@@ -540,9 +550,7 @@ module Solargraph
     # @param dst [String]
     # @return [String]
     def reduce_class dst
-      while dst =~ /^(Class|Module)\<(.*?)\>$/
-        dst = dst.sub(/^(Class|Module)\</, '').sub(/\>$/, '')
-      end
+      dst = dst.sub(/^(Class|Module)</, '').sub(/>$/, '') while dst =~ /^(Class|Module)<(.*?)>$/
       dst
     end
   end