rubocop 1.71.1 → 1.92.1

data/lib/rubocop/cop/mixin/hash_shorthand_syntax.rb

@@ -11,6 +11,33 @@ module RuboCop
       DO_NOT_MIX_OMIT_VALUE_MSG = "#{DO_NOT_MIX_MSG_PREFIX} #{OMIT_HASH_VALUE_MSG}"
       DO_NOT_MIX_EXPLICIT_VALUE_MSG = "#{DO_NOT_MIX_MSG_PREFIX} #{EXPLICIT_HASH_VALUE_MSG}"
 
+      # A keyword parameter can be named after a keyword, as in `def foo(if:)`,
+      # but the parameter can only be referenced by an omitted hash value,
+      # so `{ if: }` has no explicit form: `{ if: if }` is invalid Ruby.
+      KEYWORDS = %i[
+        __ENCODING__ __FILE__ __LINE__ BEGIN END alias and begin break case class def do
+        else elsif end ensure false for if in module next nil not or redo rescue retry
+        return self super then true undef unless until when while yield
+      ].to_set.freeze
+
+      DefNode = Struct.new(:node) do
+        def selector
+          if node.loc?(:selector)
+            node.loc.selector
+          else
+            node.loc.keyword
+          end
+        end
+
+        def first_argument
+          node.first_argument
+        end
+
+        def last_argument
+          node.last_argument
+        end
+      end
+
       def on_hash_for_mixed_shorthand(hash_node)
         return if ignore_mixed_hash_shorthand_syntax?(hash_node)
 
@@ -35,7 +62,7 @@ module RuboCop
           replacement = "#{hash_key_source}:"
           self.config_to_allow_offenses = { 'Enabled' => false }
         else
-          return unless node.value_omission?
+          return if !node.value_omission? || keyword_value?(node)
 
           message = EXPLICIT_HASH_VALUE_MSG
           replacement = "#{hash_key_source}: #{hash_key_source}"
@@ -69,13 +96,26 @@ module RuboCop
       def ignore_mixed_hash_shorthand_syntax?(hash_node)
         target_ruby_version <= 3.0 ||
           !%w[consistent either_consistent].include?(enforced_shorthand_syntax) ||
-          !hash_node.hash_type?
+          !hash_node.hash_type? || hash_rockets_enforced?(hash_node)
       end
 
       def ignore_hash_shorthand_syntax?(pair_node)
         target_ruby_version <= 3.0 || enforced_shorthand_syntax == 'either' ||
           %w[consistent either_consistent].include?(enforced_shorthand_syntax) ||
-          !pair_node.parent.hash_type?
+          !pair_node.parent.hash_type? || hash_rockets_enforced?(pair_node.parent)
+      end
+
+      def hash_rockets_enforced?(hash_node)
+        style == :hash_rockets || force_hash_rockets?(hash_node.pairs) ||
+          no_mixed_keys_enforces_hash_rockets?(hash_node.pairs)
+      end
+
+      def no_mixed_keys_enforces_hash_rockets?(pairs)
+        case style
+        when :no_mixed_keys then !sym_indices?(pairs) || pairs.first.delimiter == '=>'
+        when :ruby19_no_mixed_keys then !sym_indices?(pairs)
+        else false
+        end
       end
 
       def enforced_shorthand_syntax
@@ -99,7 +139,7 @@ module RuboCop
           use_modifier_form_without_parenthesized_method_call?(method_dispatch_node)
       end
 
-      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       def def_node_that_require_parentheses(node)
         last_pair = node.parent.pairs.last
         return unless last_pair.key.source == last_pair.value.source
@@ -107,13 +147,12 @@ module RuboCop
         return if dispatch_node.assignment_method?
         return if dispatch_node.parenthesized?
         return if dispatch_node.parent && parentheses?(dispatch_node.parent)
-        return if last_expression?(dispatch_node) && !method_dispatch_as_argument?(dispatch_node)
+        return if last_expression?(dispatch_node) && !requires_parentheses_context?(dispatch_node)
 
         def_node = node.each_ancestor(:call, :super, :yield).first
 
         DefNode.new(def_node) unless def_node && def_node.arguments.empty?
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
       def find_ancestor_method_dispatch_node(node)
         return unless (ancestor = node.parent.parent)
@@ -146,11 +185,11 @@ module RuboCop
         !assignment_node.right_sibling
       end
 
-      def method_dispatch_as_argument?(method_dispatch_node)
-        parent = method_dispatch_node.parent
+      def requires_parentheses_context?(node)
+        parent = node.parent
         return false unless parent
 
-        parent.type?(:call, :super, :yield)
+        parent.type?(:call, :if, :super, :until, :while, :yield)
       end
 
       def breakdown_value_types_of_hash(hash_node)
@@ -189,6 +228,8 @@ module RuboCop
       def mixed_shorthand_syntax_check(hash_value_type_breakdown)
         if hash_with_values_that_cant_be_omitted?(hash_value_type_breakdown)
           each_omitted_value_pair(hash_value_type_breakdown) do |pair_node|
+            next if keyword_value?(pair_node)
+
             hash_key_source = pair_node.key.source
             replacement = "#{hash_key_source}: #{hash_key_source}"
             register_offense(pair_node, DO_NOT_MIX_EXPLICIT_VALUE_MSG, replacement)
@@ -213,22 +254,8 @@ module RuboCop
         end
       end
 
-      DefNode = Struct.new(:node) do
-        def selector
-          if node.loc.respond_to?(:selector)
-            node.loc.selector
-          else
-            node.loc.keyword
-          end
-        end
-
-        def first_argument
-          node.first_argument
-        end
-
-        def last_argument
-          node.last_argument
-        end
+      def keyword_value?(pair_node)
+        KEYWORDS.include?(pair_node.key.value)
       end
     end
   end

data/lib/rubocop/cop/mixin/hash_subset.rb

@@ -5,7 +5,7 @@ module RuboCop
     # Common functionality for Style/HashExcept and Style/HashSlice cops.
     # It registers an offense on methods with blocks that are equivalent
     # to Hash#except or Hash#slice.
-    # rubocop:disable Metrics/ModuleLength
+    # rubocop:disable-next Metrics/ModuleLength
     module HashSubset
       include RangeHelp
       extend NodePattern::Macros
@@ -23,7 +23,7 @@ module RuboCop
           (call _ _)
           (args
             $(arg _key)
-            (arg _))
+            $(arg _))
           {
             $(send
               {(lvar _key) $_ _ | _ $_ (lvar _key)})
@@ -67,7 +67,7 @@ module RuboCop
       end
 
       def extracts_hash_subset?(block)
-        block_with_first_arg_check?(block) do |key_arg, send_node, method|
+        block_with_first_arg_check?(block) do |key_arg, value_arg, send_node, method|
           # Only consider methods that have one argument
           return false unless send_node.arguments.one?
 
@@ -76,15 +76,22 @@ module RuboCop
 
           case method
           when :include?, :exclude?
-            send_node.first_argument.source == key_arg.source
+            slices_key?(send_node, :first_argument, key_arg, value_arg)
           when :in?
-            send_node.receiver.source == key_arg.source
+            slices_key?(send_node, :receiver, key_arg, value_arg)
           else
             true
           end
         end
       end
 
+      def slices_key?(send_node, method, key_arg, value_arg)
+        return false if using_value_variable?(send_node, value_arg)
+
+        node = method == :receiver ? send_node.receiver : send_node.first_argument
+        node.source == key_arg.source
+      end
+
       def range_include?(send_node)
         # When checking `include?`, `exclude?` and `in?` for offenses, if the receiver
         # or first argument is a range, an offense should not be registered.
@@ -97,6 +104,14 @@ module RuboCop
         receiver.range_type?
       end
 
+      def using_value_variable?(send_node, value_arg)
+        # If the receiver of `include?` or `exclude?`, or the first argument of `in?` is the
+        # hash value block argument, an offense should not be registered.
+        # ie. `v.include?(k)` or `k.in?(v)`
+        (send_node.receiver.lvar_type? && send_node.receiver.name == value_arg.name) ||
+          (send_node.first_argument.lvar_type? && send_node.first_argument.name == value_arg.name)
+      end
+
       def supported_subset_method?(method)
         if active_support_extensions_enabled?
           ACTIVE_SUPPORT_SUBSET_METHODS.include?(method)
@@ -167,10 +182,18 @@ module RuboCop
         return ":\"#{value.source}\"" if value.dsym_type?
         return "\"#{value.source}\"" if value.dstr_type?
         return ":#{value.source}" if value.sym_type?
+        # The element of a `%w` array can contain characters that are special
+        # inside a single-quoted string (e.g. a `'`), so escape them rather than
+        # wrapping the raw source.
+        return to_single_quoted(value.value) if value.str_type?
 
         "'#{value.source}'"
       end
 
+      def to_single_quoted(string)
+        "'#{string.gsub(/['\\]/) { |character| "\\#{character}" }}'"
+      end
+
       def except_key(node)
         key_arg = node.argument_list.first.source
         body, = extract_body_if_negated(node.body)
@@ -183,6 +206,5 @@ module RuboCop
         range_between(node.loc.selector.begin_pos, node.parent.loc.end.end_pos)
       end
     end
-    # rubocop:enable Metrics/ModuleLength
   end
 end

data/lib/rubocop/cop/mixin/hash_transform_method/autocorrection.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module HashTransformMethod
+      # Internal helper class to hold autocorrect data
+      Autocorrection = Struct.new(:match, :block_node, :leading, :trailing) do
+        def self.from_each_with_object(node, match)
+          new(match, node, 0, 0)
+        end
+
+        def self.from_hash_brackets_map(node, match)
+          new(match, node.children.last, 'Hash['.length, ']'.length)
+        end
+
+        def self.from_map_to_h(node, match)
+          if node.parent&.block_type? && node.parent.send_node == node
+            strip_trailing_chars = 0
+          else
+            map_range = node.children.first.source_range
+            node_range = node.source_range
+            strip_trailing_chars = node_range.end_pos - map_range.end_pos
+          end
+
+          new(match, node.children.first, 0, strip_trailing_chars)
+        end
+
+        def self.from_to_h(node, match)
+          new(match, node, 0, 0)
+        end
+
+        def strip_prefix_and_suffix(node, corrector)
+          expression = node.source_range
+          corrector.remove_leading(expression, leading)
+          corrector.remove_trailing(expression, trailing)
+        end
+
+        def set_new_method_name(new_method_name, corrector)
+          range = block_node.send_node.loc.selector
+          if (send_end = block_node.send_node.loc.end)
+            # If there are arguments (only true in the `each_with_object`
+            # case)
+            range = range.begin.join(send_end)
+          end
+          corrector.replace(range, new_method_name)
+        end
+
+        def set_new_arg_name(transformed_argname, corrector)
+          corrector.replace(block_node.arguments, "|#{transformed_argname}|")
+        end
+
+        def set_new_body_expression(transforming_body_expr, corrector)
+          body_source = transforming_body_expr.source
+          if transforming_body_expr.hash_type? && !transforming_body_expr.braces?
+            body_source = "{ #{body_source} }"
+          end
+
+          corrector.replace(block_node.body, body_source)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/hash_transform_method.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'hash_transform_method/autocorrection'
+
 module RuboCop
   module Cop
     # Common functionality for Style/HashTransformKeys and
@@ -9,12 +11,34 @@ module RuboCop
 
       RESTRICT_ON_SEND = %i[[] to_h].freeze
 
-      # @!method array_receiver?(node)
-      def_node_matcher :array_receiver?, <<~PATTERN
-        {(array ...) (send _ :each_with_index) (send _ :with_index _ ?) (send _ :zip ...)}
+      # Internal helper class to hold match data
+      Captures = Struct.new(:transformed_argname, :transforming_body_expr, :unchanged_body_expr) do
+        def noop_transformation?
+          transforming_body_expr.lvar_type? &&
+            transforming_body_expr.children == [transformed_argname]
+        end
+
+        def transformation_uses_both_args?
+          transforming_body_expr.descendants.include?(unchanged_body_expr)
+        end
+
+        def use_transformed_argname?
+          transforming_body_expr.each_descendant(:lvar).any? do |node|
+            node.source == transformed_argname.to_s
+          end
+        end
+      end
+
+      # @!method hash_receiver?(node)
+      def_node_matcher :hash_receiver?, <<~PATTERN
+        {(hash ...)
+         (send _ {:to_h :to_hash :merge :merge! :update :invert :except :tally} ...)
+         (block (send _ {:group_by :to_h :tally :transform_keys :transform_keys!
+                         :transform_values :transform_values!}) ...)
+         (block (send _ :each_with_object (hash)) ...)}
       PATTERN
 
-      def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+      def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler -- the patterns matched here all name their block parameters
         on_bad_each_with_object(node) do |*match|
           handle_possible_offense(node, match, 'each_with_object')
         end
@@ -70,6 +94,10 @@ module RuboCop
 
         return unless captures.use_transformed_argname?
 
+        # A splat transforming expression (e.g. `[k, *v]`) can't be used as a
+        # standalone block return value, so the rewrite would produce invalid Ruby.
+        return if captures.transforming_body_expr.splat_type?
+
         message = "Prefer `#{new_method_name}` over `#{match_desc}`."
         add_offense(node, message: message) do |corrector|
           correction = prepare_correction(node)
@@ -113,80 +141,6 @@ module RuboCop
         correction.set_new_arg_name(captures.transformed_argname, corrector)
         correction.set_new_body_expression(captures.transforming_body_expr, corrector)
       end
-
-      # Internal helper class to hold match data
-      Captures = Struct.new(:transformed_argname, :transforming_body_expr, :unchanged_body_expr) do
-        def noop_transformation?
-          transforming_body_expr.lvar_type? &&
-            transforming_body_expr.children == [transformed_argname]
-        end
-
-        def transformation_uses_both_args?
-          transforming_body_expr.descendants.include?(unchanged_body_expr)
-        end
-
-        def use_transformed_argname?
-          transforming_body_expr.each_descendant(:lvar).any? do |node|
-            node.source == transformed_argname.to_s
-          end
-        end
-      end
-
-      # Internal helper class to hold autocorrect data
-      Autocorrection = Struct.new(:match, :block_node, :leading, :trailing) do
-        def self.from_each_with_object(node, match)
-          new(match, node, 0, 0)
-        end
-
-        def self.from_hash_brackets_map(node, match)
-          new(match, node.children.last, 'Hash['.length, ']'.length)
-        end
-
-        def self.from_map_to_h(node, match)
-          if node.parent&.block_type? && node.parent.send_node == node
-            strip_trailing_chars = 0
-          else
-            map_range = node.children.first.source_range
-            node_range = node.source_range
-            strip_trailing_chars = node_range.end_pos - map_range.end_pos
-          end
-
-          new(match, node.children.first, 0, strip_trailing_chars)
-        end
-
-        def self.from_to_h(node, match)
-          new(match, node, 0, 0)
-        end
-
-        def strip_prefix_and_suffix(node, corrector)
-          expression = node.source_range
-          corrector.remove_leading(expression, leading)
-          corrector.remove_trailing(expression, trailing)
-        end
-
-        def set_new_method_name(new_method_name, corrector)
-          range = block_node.send_node.loc.selector
-          if (send_end = block_node.send_node.loc.end)
-            # If there are arguments (only true in the `each_with_object`
-            # case)
-            range = range.begin.join(send_end)
-          end
-          corrector.replace(range, new_method_name)
-        end
-
-        def set_new_arg_name(transformed_argname, corrector)
-          corrector.replace(block_node.arguments, "|#{transformed_argname}|")
-        end
-
-        def set_new_body_expression(transforming_body_expr, corrector)
-          body_source = transforming_body_expr.source
-          if transforming_body_expr.hash_type? && !transforming_body_expr.braces?
-            body_source = "{ #{body_source} }"
-          end
-
-          corrector.replace(block_node.body, body_source)
-        end
-      end
     end
   end
 end

data/lib/rubocop/cop/mixin/indexed_method_arity.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Shared machinery for cops that compare a call site's arguments against
+    # a method signature from the project index (`Rubydex::Signature`).
+    #
+    # A signature is reduced to a shape - `[min, max, has_keywords]` where
+    # `max` is nil for a rest parameter - and the number of positional
+    # arguments a call passes is counted with Ruby's semantics for trailing
+    # keyword hashes: keywords passed to a method with no keyword parameters
+    # collapse into a single positional hash.
+    module IndexedMethodArity
+      private
+
+      def arity_satisfied?(given, min, max)
+        given >= min && (max.nil? || given <= max)
+      end
+
+      def expected_range(min, max)
+        return "#{min}+" if max.nil?
+        return min.to_s if min == max
+
+        "#{min}..#{max}"
+      end
+
+      # The agreed `[min, max, has_keywords]` shape of an indexed member's
+      # method definitions, or nil when the member is not backed by plain
+      # method definitions (attr, alias), has no signature, forwards
+      # arguments, or its definitions disagree on arity (e.g. reopened with
+      # a different one).
+      def indexed_member_shape(member)
+        definitions = member.definitions.grep(Rubydex::MethodDefinition)
+        return nil if definitions.empty?
+
+        signature_shape(definitions.flat_map(&:signatures))
+      end
+
+      def signature_shape(signatures)
+        shapes = signatures.filter_map { |signature| shape_for(signature) }.uniq
+        shapes.one? ? shapes.first : nil
+      end
+
+      def shape_for(signature)
+        return nil if signature.forward_parameter
+
+        min = signature.positional_parameters.size + signature.post_parameters.size
+
+        [min, maximum_positional(signature, min), keyword_parameters?(signature)]
+      end
+
+      def maximum_positional(signature, min)
+        return nil if signature.rest_positional_parameter
+
+        min + signature.optional_positional_parameters.size
+      end
+
+      def keyword_parameters?(signature)
+        !signature.keyword_parameters.empty? ||
+          !signature.optional_keyword_parameters.empty? ||
+          !signature.rest_keyword_parameter.nil?
+      end
+
+      # The number of positional arguments the call passes, or nil when it
+      # cannot be determined statically (argument forwarding).
+      def positional_argument_count(node, callee_has_keywords)
+        arguments = node.arguments
+        return nil if forwards_arguments?(arguments)
+
+        arguments = arguments[0...-1] if arguments.last&.block_pass_type?
+        return arguments.size unless (keyword_hash = keyword_hash(arguments.last))
+        return nil if double_splat?(keyword_hash)
+
+        # A keyword-style hash passed to a method with no keyword parameters is
+        # received as a single positional hash argument.
+        callee_has_keywords ? arguments.size - 1 : arguments.size
+      end
+
+      def forwards_arguments?(arguments)
+        arguments.any? do |argument|
+          argument.type?(:splat, :forwarded_args, :forwarded_restarg, :forwarded_kwrestarg)
+        end
+      end
+
+      def keyword_hash(node)
+        node if node&.hash_type? && !node.braces?
+      end
+
+      def double_splat?(hash_node)
+        hash_node.each_child_node.any?(&:kwsplat_type?)
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/line_length_help.rb

@@ -8,8 +8,27 @@ module RuboCop
 
       private
 
-      def ignore_cop_directives?
-        config.for_cop('Layout/LineLength')['IgnoreCopDirectives']
+      def allow_rbs_inline_annotation?
+        config.for_cop('Layout/LineLength')['AllowRBSInlineAnnotation']
+      end
+
+      def rbs_inline_annotation_on_source_line?(line_index)
+        source_line_number = line_index + processed_source.buffer.first_line
+        comment = processed_source.comment_at_line(source_line_number)
+
+        return false unless comment
+
+        comment.text.start_with?(/#:|#\[.+\]|#\|/)
+      end
+
+      def allow_cop_directives?
+        # TODO: This logic for backward compatibility with deprecated `IgnoreCopDirectives` option.
+        # The following three lines will be removed in RuboCop 2.0.
+        ignore_cop_directives = config.for_cop('Layout/LineLength')['IgnoreCopDirectives']
+        return true if ignore_cop_directives
+        return false if ignore_cop_directives == false
+
+        config.for_cop('Layout/LineLength')['AllowCopDirectives']
       end
 
       def directive_on_source_line?(line_index)
@@ -25,20 +44,24 @@ module RuboCop
         config.for_cop('Layout/LineLength')['AllowURI']
       end
 
-      def allowed_uri_position?(line, uri_range)
-        uri_range.begin < max_line_length && uri_range.end == line_length(line)
+      def allow_qualified_name?
+        config.for_cop('Layout/LineLength')['AllowQualifiedName']
+      end
+
+      def allowed_position?(line, range)
+        range.begin < max_line_length && range.end == line_length(line)
       end
 
       def line_length(line)
         line.length + indentation_difference(line)
       end
 
-      def find_excessive_uri_range(line)
-        last_uri_match = match_uris(line).last
-        return nil unless last_uri_match
+      def find_excessive_range(line, type)
+        last_match = (type == :uri ? match_uris(line) : match_qualified_names(line)).last
+        return nil unless last_match
 
-        begin_position, end_position = last_uri_match.offset(0)
-        end_position = extend_uri_end_position(line, end_position)
+        begin_position, end_position = last_match.offset(0)
+        end_position = extend_end_position(line, end_position)
 
         line_indentation_difference = indentation_difference(line)
         begin_position += line_indentation_difference
@@ -57,6 +80,14 @@ module RuboCop
         matches
       end
 
+      def match_qualified_names(string)
+        matches = []
+        string.scan(qualified_name_regexp) do
+          matches << $LAST_MATCH_INFO
+        end
+        matches
+      end
+
       def indentation_difference(line)
         return 0 unless tab_indentation_width
 
@@ -70,7 +101,7 @@ module RuboCop
         index * (tab_indentation_width - 1)
       end
 
-      def extend_uri_end_position(line, end_position)
+      def extend_end_position(line, end_position)
         # Extend the end position YARD comments with linked URLs of the form {<uri> <title>}
         if line&.match(/{(\s|\S)*}$/)
           match = line[end_position..line_length(line)]&.match(/(\s|\S)*}/)
@@ -97,10 +128,20 @@ module RuboCop
           # Additionally, the RFC2396_PARSER alias is only available on 3.4 for now.
           # Extra info at https://github.com/ruby/uri/issues/118
           parser = defined?(URI::RFC2396_PARSER) ? URI::RFC2396_PARSER : URI::DEFAULT_PARSER
-          parser.make_regexp(config.for_cop('Layout/LineLength')['URISchemes'])
+          schemes = config.for_cop('Layout/LineLength')['URISchemes']
+          regexp = parser.make_regexp(schemes)
+
+          # `make_regexp` in uri 1.1.0+ matches schemes case-insensitively, which makes
+          # constant paths like `Http::UploadedFile` look like URIs. Require the exact case
+          # given in `URISchemes`.
+          schemes ? /(?=#{Regexp.union(schemes)}:)#{regexp}/ : regexp
         end
       end
 
+      def qualified_name_regexp
+        /\b(?:[A-Z][A-Za-z0-9_]*::)+[A-Za-z_][A-Za-z0-9_]*\b/
+      end
+
       def valid_uri?(uri_ish_string)
         URI.parse(uri_ish_string)
         true

data/lib/rubocop/cop/mixin/method_complexity.rb

@@ -30,6 +30,7 @@ module RuboCop
       end
 
       alias on_numblock on_block
+      alias on_itblock on_block
 
       private
 
@@ -72,7 +73,7 @@ module RuboCop
 
       def location(node)
         if LSP.enabled?
-          end_range = node.loc.respond_to?(:name) ? node.loc.name : node.loc.begin
+          end_range = node.loc?(:name) ? node.loc.name : node.loc.begin
           node.source_range.begin.join(end_range)
         else
           node.source_range

data/lib/rubocop/cop/mixin/min_branches_count.rb

@@ -32,7 +32,9 @@ module RuboCop
         branches << node.if_branch
 
         else_branch = node.else_branch
-        if_conditional_branches(else_branch, branches) if else_branch&.if_type?
+        if else_branch&.if_type? && else_branch.elsif?
+          if_conditional_branches(else_branch, branches)
+        end
         branches
       end
     end