super-pro-sys 0.0.1

data/rubocop-1.88.1/lib/rubocop/cop/lint/unmodified_reduce_accumulator.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Looks for `reduce` or `inject` blocks where the value returned (implicitly or
+      # explicitly) does not include the accumulator. A block is considered valid as
+      # long as at least one return value includes the accumulator.
+      #
+      # If the accumulator is not included in the return value, then the entire
+      # block will just return a transformation of the last element value, and
+      # could be rewritten as such without a loop.
+      #
+      # Also catches instances where an index of the accumulator is returned, as
+      # this may change the type of object being retained.
+      #
+      # NOTE: For the purpose of reducing false positives, this cop only flags
+      # returns in `reduce` blocks where the element is the only variable in
+      # the expression (since we will not be able to tell what other variables
+      # relate to via static analysis).
+      #
+      # @example
+      #
+      #   # bad
+      #   (1..4).reduce(0) do |acc, el|
+      #     el * 2
+      #   end
+      #
+      #   # bad, may raise a NoMethodError after the first iteration
+      #   %w(a b c).reduce({}) do |acc, letter|
+      #     acc[letter] = true
+      #   end
+      #
+      #   # good
+      #   (1..4).reduce(0) do |acc, el|
+      #     acc + el * 2
+      #   end
+      #
+      #   # good, element is returned but modified using the accumulator
+      #   values.reduce do |acc, el|
+      #     el << acc
+      #     el
+      #   end
+      #
+      #   # good, returns the accumulator instead of the index
+      #   %w(a b c).reduce({}) do |acc, letter|
+      #     acc[letter] = true
+      #     acc
+      #   end
+      #
+      #   # good, at least one branch returns the accumulator
+      #   values.reduce(nil) do |result, value|
+      #     break result if something?
+      #     value
+      #   end
+      #
+      #   # good, recursive
+      #   keys.reduce(self) { |result, key| result[key] }
+      #
+      #   # ignored as the return value cannot be determined
+      #   enum.reduce do |acc, el|
+      #     x = foo(acc, el)
+      #     bar(x)
+      #   end
+      class UnmodifiedReduceAccumulator < Base
+        MSG = 'Ensure the accumulator `%<accum>s` will be modified by `%<method>s`.'
+        MSG_INDEX = 'Do not return an element of the accumulator in `%<method>s`.'
+
+        # @!method reduce_with_block?(node)
+        def_node_matcher :reduce_with_block?, <<~PATTERN
+          {
+            (block (call _recv {:reduce :inject} ...) args ...)
+            (numblock (call _recv {:reduce :inject} ...) ...)
+          }
+        PATTERN
+
+        # @!method accumulator_index?(node, accumulator_name)
+        def_node_matcher :accumulator_index?, <<~PATTERN
+          (send (lvar %1) {:[] :[]=} ...)
+        PATTERN
+
+        # @!method element_modified?(node, element_name)
+        def_node_search :element_modified?, <<~PATTERN
+          {
+            (send _receiver !{:[] :[]=} <`(lvar %1) `_ ...>)               # method(el, ...)
+            (send (lvar %1) _message <{ivar gvar cvar lvar send} ...>)     # el.method(...)
+            (lvasgn %1 _)                                                  # el = ...
+            (%RuboCop::AST::Node::SHORTHAND_ASSIGNMENTS (lvasgn %1) ... _) # el += ...
+          }
+        PATTERN
+
+        # @!method lvar_used?(node, name)
+        def_node_matcher :lvar_used?, <<~PATTERN
+          {
+            (lvar %1)
+            (lvasgn %1 ...)
+            (send (lvar %1) :<< ...)
+            (dstr (begin (lvar %1)))
+            (%RuboCop::AST::Node::SHORTHAND_ASSIGNMENTS (lvasgn %1))
+          }
+        PATTERN
+
+        # @!method expression_values(node)
+        def_node_search :expression_values, <<~PATTERN
+          {
+            (%RuboCop::AST::Node::VARIABLES $_)
+            (%RuboCop::AST::Node::EQUALS_ASSIGNMENTS $_ ...)
+            (send (%RuboCop::AST::Node::VARIABLES $_) :<< ...)
+            $(send _ _)
+            (dstr (begin {(%RuboCop::AST::Node::VARIABLES $_)}))
+            (%RuboCop::AST::Node::SHORTHAND_ASSIGNMENTS (%RuboCop::AST::Node::EQUALS_ASSIGNMENTS $_) ...)
+          }
+        PATTERN
+
+        def on_block(node)
+          return unless node.body
+          return unless reduce_with_block?(node)
+          return unless node.argument_list.length >= 2
+
+          check_return_values(node)
+        end
+        alias on_numblock on_block
+        alias on_itblock on_block
+
+        private
+
+        # Return values in a block are either the value given to next,
+        # the last line of a multiline block, or the only line of the block
+        def return_values(block_body_node)
+          nodes = [block_body_node.begin_type? ? block_body_node.child_nodes.last : block_body_node]
+
+          block_body_node.each_descendant(:next, :break) do |n|
+            # Ignore `next`/`break` inside an inner block
+            next if n.each_ancestor(:any_block).first != block_body_node.parent
+            next unless n.first_argument
+
+            nodes << n.first_argument
+          end
+
+          nodes
+        end
+
+        def check_return_values(block_node)
+          return_values = return_values(block_node.body)
+          accumulator_name = block_arg_name(block_node, 0)
+          element_name = block_arg_name(block_node, 1)
+          message_opts = { method: block_node.method_name, accum: accumulator_name }
+
+          if (node = returned_accumulator_index(return_values, accumulator_name, element_name))
+            add_offense(node, message: format(MSG_INDEX, message_opts))
+          elsif potential_offense?(return_values, block_node.body, element_name, accumulator_name)
+            return_values.each do |return_val|
+              unless acceptable_return?(return_val, element_name)
+                add_offense(return_val, message: format(MSG, message_opts))
+              end
+            end
+          end
+        end
+
+        def block_arg_name(node, index)
+          node.argument_list[index].name
+        end
+
+        # Look for an index of the accumulator being returned, except where the index
+        # is the element.
+        # This is always an offense, in order to try to catch potential exceptions
+        # due to type mismatches
+        def returned_accumulator_index(return_values, accumulator_name, element_name)
+          return_values.detect do |val|
+            next unless accumulator_index?(val, accumulator_name)
+            next true if val.method?(:[]=)
+
+            val.arguments.none? { |arg| lvar_used?(arg, element_name) }
+          end
+        end
+
+        def potential_offense?(return_values, block_body, element_name, accumulator_name)
+          !(element_modified?(block_body, element_name) ||
+            returns_accumulator_anywhere?(return_values, accumulator_name))
+        end
+
+        # If the accumulator is used in any return value, the node is acceptable since
+        # the accumulator has a chance to change each iteration
+        def returns_accumulator_anywhere?(return_values, accumulator_name)
+          return_values.any? { |node| lvar_used?(node, accumulator_name) }
+        end
+
+        # Determine if a return value is acceptable for the purposes of this cop
+        # If it is an expression containing the accumulator, it is acceptable
+        # Otherwise, it is only unacceptable if it contains the iterated element, since we
+        # otherwise do not have enough information to prevent false positives.
+        def acceptable_return?(return_val, element_name)
+          vars = expression_values(return_val).uniq
+          return true if vars.none? || (vars - [element_name]).any?
+
+          false
+        end
+
+        # Exclude `begin` nodes inside a `dstr` from being collected by `return_values`
+        def allowed_type?(parent_node)
+          !parent_node.dstr_type?
+        end
+      end
+    end
+  end
+end

data/rubocop-1.88.1/lib/rubocop/cop/lint/unreachable_code.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for unreachable code.
+      # The check is based on the presence of flow-of-control
+      # statements in non-final position in `begin` (implicit) blocks.
+      #
+      # @example
+      #
+      #   # bad
+      #   def some_method
+      #     return
+      #     do_something
+      #   end
+      #
+      #   # bad
+      #   def some_method
+      #     if cond
+      #       return
+      #     else
+      #       return
+      #     end
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   def some_method
+      #     do_something
+      #   end
+      class UnreachableCode < Base
+        MSG = 'Unreachable code detected.'
+
+        def initialize(config = nil, options = nil)
+          super
+          @redefined = []
+          @instance_eval_count = 0
+        end
+
+        def on_block(node)
+          @instance_eval_count += 1 if instance_eval_block?(node)
+        end
+
+        alias on_numblock on_block
+        alias on_itblock on_block
+
+        def after_block(node)
+          @instance_eval_count -= 1 if instance_eval_block?(node)
+        end
+
+        def on_begin(node)
+          expressions = *node
+
+          expressions.each_cons(2) do |expression1, expression2|
+            next unless flow_expression?(expression1)
+
+            add_offense(expression2)
+          end
+        end
+
+        alias on_kwbegin on_begin
+
+        private
+
+        def redefinable_flow_method?(method)
+          %i[raise fail throw exit exit! abort].include? method
+        end
+
+        # @!method flow_command?(node)
+        def_node_matcher :flow_command?, <<~PATTERN
+          {
+            return next break retry redo
+            (send
+             {nil? (const {nil? cbase} :Kernel)}
+             #redefinable_flow_method?
+             ...)
+          }
+        PATTERN
+
+        # rubocop:disable Metrics/MethodLength
+        def flow_expression?(node)
+          return report_on_flow_command?(node) if flow_command?(node)
+
+          case node.type
+          when :begin, :kwbegin
+            expressions = *node
+            expressions.any? { |expr| flow_expression?(expr) }
+          when :if
+            check_if(node)
+          when :case, :case_match
+            check_case(node)
+          when :def, :defs
+            register_redefinition(node)
+            false
+          else
+            false
+          end
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        def check_if(node)
+          if_branch = node.if_branch
+          else_branch = node.else_branch
+          if_branch && else_branch && flow_expression?(if_branch) && flow_expression?(else_branch)
+        end
+
+        def check_case(node)
+          else_branch = node.else_branch
+          return false unless else_branch
+          return false unless flow_expression?(else_branch)
+
+          branches = node.case_type? ? node.when_branches : node.in_pattern_branches
+
+          branches.all? { |branch| branch.body && flow_expression?(branch.body) }
+        end
+
+        def register_redefinition(node)
+          @redefined << node.method_name if redefinable_flow_method?(node.method_name)
+        end
+
+        def instance_eval_block?(node)
+          node.any_block_type? && node.method?(:instance_eval)
+        end
+
+        def report_on_flow_command?(node)
+          return true unless node.send_type?
+
+          # By the contract of this function, this case means that
+          # the method is called on `Kernel` in which case we
+          # always want to report a warning.
+          return true if node.receiver
+
+          # Inside an `instance_eval` we have no way to tell the
+          # type of `self` just by looking at the AST, so we can't
+          # tell if the give function that's called has been
+          # redefined or not, so to avoid false positives, we silence
+          # the warning.
+          return false if @instance_eval_count.positive?
+
+          !@redefined.include? node.method_name
+        end
+      end
+    end
+  end
+end

data/rubocop-1.88.1/lib/rubocop/cop/lint/unreachable_loop.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for loops that will have at most one iteration.
+      #
+      # A loop that can never reach the second iteration is a possible error in the code.
+      # In rare cases where only one iteration (or at most one iteration) is intended behavior,
+      # the code should be refactored to use `if` conditionals.
+      #
+      # NOTE: Block methods that are used with ``Enumerable``s are considered to be loops.
+      #
+      # `AllowedPatterns` can be used to match against the block receiver in order to allow
+      # code that would otherwise be registered as an offense (eg. `times` used not in an
+      # `Enumerable` context).
+      #
+      # @example
+      #   # bad
+      #   while node
+      #     do_something(node)
+      #     node = node.parent
+      #     break
+      #   end
+      #
+      #   # good
+      #   while node
+      #     do_something(node)
+      #     node = node.parent
+      #   end
+      #
+      #   # bad
+      #   def verify_list(head)
+      #     item = head
+      #     begin
+      #       if verify(item)
+      #         return true
+      #       else
+      #         return false
+      #       end
+      #     end while(item)
+      #   end
+      #
+      #   # good
+      #   def verify_list(head)
+      #     item = head
+      #     begin
+      #       if verify(item)
+      #         item = item.next
+      #       else
+      #         return false
+      #       end
+      #     end while(item)
+      #
+      #     true
+      #   end
+      #
+      #   # bad
+      #   def find_something(items)
+      #     items.each do |item|
+      #       if something?(item)
+      #         return item
+      #       else
+      #         raise NotFoundError
+      #       end
+      #     end
+      #   end
+      #
+      #   # good
+      #   def find_something(items)
+      #     items.each do |item|
+      #       if something?(item)
+      #         return item
+      #       end
+      #     end
+      #     raise NotFoundError
+      #   end
+      #
+      #   # bad
+      #   2.times { raise ArgumentError }
+      #
+      # @example AllowedPatterns: ['(exactly|at_least|at_most)\(\d+\)\.times'] (default)
+      #
+      #   # good
+      #   exactly(2).times { raise StandardError }
+      class UnreachableLoop < Base
+        include AllowedPattern
+
+        MSG = 'This loop will have at most one iteration.'
+        CONTINUE_KEYWORDS = %i[next redo].freeze
+
+        def on_while(node)
+          check(node)
+        end
+        alias on_until on_while
+        alias on_while_post on_while
+        alias on_until_post on_while
+        alias on_for on_while
+
+        def on_block(node)
+          check(node) if loop_method?(node)
+        end
+
+        alias on_numblock on_block
+        alias on_itblock on_block
+
+        private
+
+        def loop_method?(node)
+          return false unless node.any_block_type?
+
+          send_node = node.send_node
+          loopable = send_node.enumerable_method? || send_node.enumerator_method? ||
+                     send_node.method?(:loop)
+          loopable && !matches_allowed_pattern?(send_node.source)
+        end
+
+        def check(node)
+          statements = statements(node)
+          break_statement = statements.find { |statement| break_statement?(statement) }
+          return unless break_statement
+
+          unless preceded_by_continue_statement?(break_statement) ||
+                 conditional_continue_keyword?(break_statement)
+            add_offense(node)
+          end
+        end
+
+        def statements(node)
+          body = node.body
+
+          if body.nil?
+            []
+          elsif body.begin_type?
+            body.children
+          else
+            [body]
+          end
+        end
+
+        # @!method break_command?(node)
+        def_node_matcher :break_command?, <<~PATTERN
+          {
+            return break
+            (send
+             {nil? (const {nil? cbase} :Kernel)}
+             {:raise :fail :throw :exit :exit! :abort}
+             ...)
+          }
+        PATTERN
+
+        def break_statement?(node)
+          return true if break_command?(node)
+
+          case node.type
+          when :begin, :kwbegin
+            statements = *node
+            break_statement = statements.find { |statement| break_statement?(statement) }
+            break_statement && !preceded_by_continue_statement?(break_statement)
+          when :if
+            check_if(node)
+          when :case, :case_match
+            check_case(node)
+          else
+            false
+          end
+        end
+
+        def check_if(node)
+          if_branch = node.if_branch
+          else_branch = node.else_branch
+          if_branch && else_branch && break_statement?(if_branch) && break_statement?(else_branch)
+        end
+
+        def check_case(node)
+          else_branch = node.else_branch
+          return false unless else_branch
+          return false unless break_statement?(else_branch)
+
+          branches = if node.case_type?
+                       node.when_branches
+                     else
+                       node.in_pattern_branches
+                     end
+
+          branches.all? { |branch| branch.body && break_statement?(branch.body) }
+        end
+
+        def preceded_by_continue_statement?(break_statement)
+          break_statement.left_siblings.any? do |sibling|
+            # Numblocks have the arguments count as a number or,
+            # itblocks have `:it` symbol in the AST.
+            next if sibling.is_a?(Integer) || sibling.is_a?(Symbol)
+            next if sibling.loop_keyword? || loop_method?(sibling)
+
+            sibling.each_descendant(*CONTINUE_KEYWORDS).any?
+          end
+        end
+
+        def conditional_continue_keyword?(break_statement)
+          or_node = break_statement.each_descendant(:or).to_a.last
+
+          or_node && CONTINUE_KEYWORDS.include?(or_node.rhs.type)
+        end
+      end
+    end
+  end
+end

data/rubocop-1.88.1/lib/rubocop/cop/lint/unreachable_pattern_branch.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for unreachable `in` pattern branches in `case...in` statements.
+      #
+      # An `in` branch is unreachable when a previous branch uses an unguarded
+      # catch-all pattern that matches any value unconditionally. Any `in` branches
+      # (and `else`) that follow such a catch-all are dead code.
+      #
+      # A catch-all pattern is one of:
+      #
+      # * A bare variable capture (`in x`)
+      # * An underscore (`in _`)
+      # * A pattern alias where the left side is a catch-all (`in _ => y`)
+      # * An alternation pattern where at least one alternative is a catch-all
+      #   (`in _ | Integer`)
+      #
+      # NOTE: A catch-all pattern with a guard clause (e.g., `in _ if condition`)
+      # does NOT make subsequent branches unreachable because the guard might
+      # not be satisfied.
+      #
+      # @example
+      #
+      #   # bad
+      #   case value
+      #   in Integer
+      #     handle_integer
+      #   in x
+      #     handle_other
+      #   in String
+      #     handle_string
+      #   else
+      #     handle_else
+      #   end
+      #
+      #   # good
+      #   case value
+      #   in Integer
+      #     handle_integer
+      #   in String
+      #     handle_string
+      #   in x
+      #     handle_other
+      #   end
+      #
+      #   # bad - else is unreachable after catch-all
+      #   case value
+      #   in Integer
+      #     handle_integer
+      #   in _
+      #     handle_other
+      #   else
+      #     handle_else
+      #   end
+      #
+      #   # good - guard clause means catch-all might not match
+      #   case value
+      #   in x if x.positive?
+      #     handle_positive
+      #   in Integer
+      #     handle_integer
+      #   else
+      #     handle_other
+      #   end
+      #
+      class UnreachablePatternBranch < Base
+        extend TargetRubyVersion
+
+        MSG = 'Unreachable `in` pattern branch detected.'
+        MSG_ELSE = 'Unreachable `else` branch detected.'
+
+        minimum_target_ruby_version 2.7
+
+        def on_case_match(case_node)
+          catch_all_found = false
+
+          case_node.in_pattern_branches.each do |in_pattern_node|
+            if catch_all_found
+              add_offense(in_pattern_node)
+              next
+            end
+
+            pattern = in_pattern_node.pattern
+            guard = in_pattern_node.children[1]
+
+            catch_all_found = true if catch_all_pattern?(pattern) && guard.nil?
+          end
+
+          return unless catch_all_found && case_node.else?
+
+          add_offense(case_node.loc.else, message: MSG_ELSE)
+        end
+
+        private
+
+        def catch_all_pattern?(pattern)
+          case pattern.type
+          when :match_var
+            true
+          when :match_as, :begin
+            catch_all_pattern?(pattern.children[0])
+          when :match_alt
+            pattern.children.any? { |child| catch_all_pattern?(child) }
+          else
+            false
+          end
+        end
+      end
+    end
+  end
+end