what_dya_return 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0f7dfddc7b09e314b0c96b8e8ad634f517f03e5252722c8aa16f3883caba8293
-  data.tar.gz: 3f6ec35cc912717543a3811c38bfbce34a92b9256ea753d02a0580e06cb252d8
+  metadata.gz: 8b901658269a99b9dde7f5962dc897a168e671fa91c278eb6172c9f7e774ab75
+  data.tar.gz: 4570ad3cfcc23332ee91170ddcd08b68502f3e10820c0a5d2f91ad1f39591e6d
 SHA512:
-  metadata.gz: 11effd57e51749aac58251616c68d3494eab40bff6d0df63b4c8f29e182ff17fa4e35210f8c57b298b9efe68699f7822acb4c3a3af761a4f66bd7835e641aad0
-  data.tar.gz: 1718c98ba23d4801ba67449843e2742d3f4449a867fa00518c683328765f404263704ef4a3389685c0d55ef782fa83b4a0210a0c7936b7e4991b4fff709bd2fe
+  metadata.gz: 1271b830e730bad853f94a84df88f15bd6d914ca5dd47a43a0708ae48021d7943766a9636bebd038846ba230e0c5d2fd3c593d05f7ad1aa0f2cd1f49cae6a0b6
+  data.tar.gz: c8614901b3d93b637d7035eec6d4ef2d4a062d7072b831ec5d7ad0d060515ff18e01db4987d6eb24ed62a0d483def6789e891d3046f13edb2cbbb42e5645bd47

data/.rubocop.yml

@@ -1,10 +1,19 @@
 require:
   - rubocop-performance
 
+AllCops:
+  SuggestExtensions: false
+
 Metrics/ClassLength:
   Exclude:
+    - 'lib/what_dya_return/extractor.rb'
+    - 'lib/what_dya_return/processor.rb'
     - 'test/what_dya_return/extractor_test.rb'
 
 Metrics/MethodLength:
+  Max: 30
   Exclude:
-    - 'test/what_dya_return/extractor_test.rb'
+    - 'test/*'
+
+Style/Documentation:
+  Enabled: false

data/README.md

@@ -21,7 +21,7 @@ end
 ## Usage
 
 ```rb
-result = WhatDyaReturn::Extractor.new.extract(<<-CODE)
+WhatDyaReturn::Extractor.new.extract(<<-CODE)
   def foo
     if bar
       42
@@ -30,8 +30,60 @@ result = WhatDyaReturn::Extractor.new.extract(<<-CODE)
     end
   end
 CODE
+# => ['42', "'baz'"]
+
+WhatDyaReturn::Extractor.new.extract(<<-CODE)
+  def foo
+    return 42 if bar # `bar` is not evaluated in this gem
+
+    123
+  end
+CODE
+# => ['42', '123']
+
+WhatDyaReturn::Extractor.new.extract(<<-CODE)
+  def foo
+    return 42
+
+    123
+  end
+CODE
+# => ['42']
+
+puts WhatDyaReturn::Extractor.new.extract(<<-CODE)
+  def foo
+    do_something
+  rescue
+    2
+  else
+    3
+  ensure
+    4
+  end
+CODE
+# => ['3', '2']
+
+puts WhatDyaReturn::Extractor.new.extract(<<-CODE)
+  def foo
+    for i in 1..10
+      1
+      break 2 if baz
+      3
+    end
+  end
+CODE
+# => ['2', '1..10']
+
+puts WhatDyaReturn::Extractor.new.extract(<<-CODE)
+  def foo
+    1.times do
+      break 2 if bar
+      3
+    end
+  end
+CODE
+# => ['2', '1.times']
 
-result # => ['42', "'baz'"]
 ```
 
 ## Caution

data/lib/what_dya_return/ast/builder.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module WhatDyaReturn
+  module AST
+    #
+    # This file is based on https://github.com/rubocop/rubocop-ast/blob/v1.28.1/lib/rubocop/ast/builder.rb
+    # The original code is licensed under the MIT License.
+    #
+    # https://github.com/rubocop/rubocop-ast/blob/v1.28.1/LICENSE.txt
+    #
+    class Builder < Parser::Builders::Default
+      NODE_MAP = {
+        def: DefNode,
+        begin: BeginNode,
+        kwbegin: BeginNode,
+        array: ArrayNode,
+        return: ReturnNode,
+        if: IfNode,
+        case: CaseNode,
+        when: WhenNode,
+        rescue: RescueNode,
+        resbody: ResbodyNode,
+        ensure: EnsureNode,
+        while: WhileNode,
+        until: UntilNode,
+        for: ForNode,
+        break: BreakNode,
+        next: NextNode,
+        block: BlockNode
+      }.freeze
+
+      #
+      # NOTE: Reason why wrap with ArrayNode if the node is `return` or `break` and has multiple children.
+      #
+      #   To treat `return 1, 2` like `return [1, 2]`.
+      #
+      # @return [Node]
+      #
+      def n(type, children, source_map)
+        children = [ArrayNode.new(:array, children)] if %i[return break].include?(type) && children.size > 1
+
+        node_klass(type).new(type, children, location: source_map)
+      end
+
+      private
+
+      def node_klass(type)
+        NODE_MAP[type] || Node
+      end
+    end
+  end
+end

data/lib/what_dya_return/ast/node/array_node.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module WhatDyaReturn
+  module AST
+    class ArrayNode < ::RuboCop::AST::ArrayNode
+    end
+  end
+end

data/lib/what_dya_return/ast/node/begin_node.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module WhatDyaReturn
   module AST
     class BeginNode < ::RuboCop::AST::Node

data/lib/what_dya_return/ast/node/block_node.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module WhatDyaReturn
+  module AST
+    class BlockNode < ::RuboCop::AST::BlockNode
+    end
+  end
+end

data/lib/what_dya_return/ast/node/break_node.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module WhatDyaReturn
+  module AST
+    class BreakNode < ::RuboCop::AST::BreakNode
+    end
+  end
+end

data/lib/what_dya_return/ast/node/case_node.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module WhatDyaReturn
+  module AST
+    class CaseNode < ::RuboCop::AST::CaseNode
+    end
+  end
+end

data/lib/what_dya_return/ast/node/def_node.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module WhatDyaReturn
+  module AST
+    class DefNode < ::RuboCop::AST::DefNode
+    end
+  end
+end

data/lib/what_dya_return/ast/node/ensure_node.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module WhatDyaReturn
+  module AST
+    class EnsureNode < ::RuboCop::AST::EnsureNode
+    end
+  end
+end

data/lib/what_dya_return/ast/node/for_node.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module WhatDyaReturn
+  module AST
+    class ForNode < ::RuboCop::AST::ForNode
+    end
+  end
+end

data/lib/what_dya_return/{ext/rubocop/ast → ast}/node/if_node.rb

@@ -1,8 +1,11 @@
 # frozen_string_literal: true
 
-module RuboCop
+module WhatDyaReturn
   module AST
-    class RuboCop::AST::IfNode
+    #
+    # A node extension for `if` nodes.
+    #
+    class IfNode < ::RuboCop::AST::IfNode
       #
       # @example
       #

data/lib/what_dya_return/ast/node/next_node.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module WhatDyaReturn
+  module AST
+    class NextNode < ::RuboCop::AST::NextNode
+    end
+  end
+end

data/lib/what_dya_return/ast/node/resbody_node.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module WhatDyaReturn
+  module AST
+    class ResbodyNode < ::RuboCop::AST::ResbodyNode
+    end
+  end
+end

data/lib/what_dya_return/ast/node/rescue_node.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module WhatDyaReturn
+  module AST
+    class RescueNode < ::RuboCop::AST::RescueNode
+    end
+  end
+end

data/lib/what_dya_return/ast/node/return_node.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module WhatDyaReturn
+  module AST
+    class ReturnNode < ::RuboCop::AST::ReturnNode
+    end
+  end
+end

data/lib/what_dya_return/ast/node/until_node.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module WhatDyaReturn
+  module AST
+    #
+    # A node extension for `if` nodes.
+    #
+    class UntilNode < ::RuboCop::AST::UntilNode
+      #
+      # @example
+      #
+      #   until true
+      #     42 # unreachable
+      #   end
+      #
+      # @return [Boolean]
+      #
+      def body_reachable?
+        condition.truthy_literal?.!
+      end
+    end
+  end
+end

data/lib/what_dya_return/ast/node/when_node.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module WhatDyaReturn
+  module AST
+    class WhenNode < ::RuboCop::AST::WhenNode
+    end
+  end
+end

data/lib/what_dya_return/ast/node/while_node.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module WhatDyaReturn
+  module AST
+    #
+    # A node extension for `while` nodes.
+    #
+    class WhileNode < ::RuboCop::AST::WhileNode
+      #
+      # @example
+      #
+      #   while false # or `nil`
+      #     42 # unreachable
+      #   end
+      #
+      # @return [Boolean]
+      #
+      def body_reachable?
+        condition.falsey_literal?.!
+      end
+    end
+  end
+end

data/lib/what_dya_return/ast/node.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module WhatDyaReturn
+  module AST
+    class Node < ::RuboCop::AST::Node
+    end
+  end
+end

data/lib/what_dya_return/ast/processed_source.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module WhatDyaReturn
+  module AST
+    #
+    # Override `RuboCop::AST::ProcessedSource#create_parser` to
+    # use `WhatDyaReturn::AST::Builder` instead of `RuboCop::AST::Builder`
+    #
+    class ProcessedSource < ::RuboCop::AST::ProcessedSource
+      def create_parser(ruby_version)
+        builder = Builder.new
+
+        parser_class(ruby_version).new(builder).tap do |parser|
+          parser.diagnostics.all_errors_are_fatal = (RUBY_ENGINE != 'ruby')
+          parser.diagnostics.ignore_warnings = false
+          parser.diagnostics.consumer = lambda do |diagnostic|
+            @diagnostics << diagnostic
+          end
+        end
+      end
+    end
+  end
+end

data/lib/what_dya_return/ast.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'rubocop-ast'
+
+require_relative 'ext/rubocop-ast/node'
+
+require_relative 'ast/node'
+require_relative 'ast/node/def_node'
+require_relative 'ast/node/begin_node'
+require_relative 'ast/node/array_node'
+require_relative 'ast/node/return_node'
+require_relative 'ast/node/if_node'
+require_relative 'ast/node/case_node'
+require_relative 'ast/node/when_node'
+require_relative 'ast/node/rescue_node'
+require_relative 'ast/node/resbody_node'
+require_relative 'ast/node/ensure_node'
+require_relative 'ast/node/while_node'
+require_relative 'ast/node/until_node'
+require_relative 'ast/node/for_node'
+require_relative 'ast/node/break_node'
+require_relative 'ast/node/block_node'
+require_relative 'ast/node/next_node'
+require_relative 'ast/builder'
+require_relative 'ast/processed_source'

data/lib/what_dya_return/ext/rubocop-ast/node.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module WhatDyaReturn
+  #
+  # A RuboCop::AST::Node refinement.
+  #
+  module NodeRefinary
+    refine ::RuboCop::AST::Node do
+      #
+      # @see WhatDyaReturn::StatementChecker#returnable_statement?
+      #
+      def returnable_statement?
+        StatementChecker.returnable_statement?(self)
+      end
+
+      #
+      # @see WhatDyaReturn::StatementChecker#reachable_to_next_statement?
+      #
+      def reachable_to_next_statement?
+        StatementChecker.reachable_to_next_statement?(self)
+      end
+    end
+  end
+end

data/lib/what_dya_return/extractor.rb

@@ -1,23 +1,37 @@
 # frozen_string_literal: true
 
-require 'rubocop-ast'
 require 'unparser'
 require_relative 'processor'
 
 module WhatDyaReturn
   class Extractor
+    #
+    # Extracts the return value candidates from `source_code`
+    #
+    # @example
+    #
+    #   WhatDyaReturn::Extractor.new.extract(<<-CODE)
+    #     def foo
+    #       if bar
+    #         42
+    #       else
+    #         'baz'
+    #       end
+    #     end
+    #   CODE
+    #   # => ['42', '"baz"']
     #
     # @param [String] source_code
     # @return [Array<String>]
     # @raise [WhatDyaReturn::SyntaxErrfor] if `source_code` cannot be parsed
     #
     def extract(source_code)
-      processed = ::RuboCop::AST::ProcessedSource.new(source_code, RUBY_VERSION.to_f)
+      processed = AST::ProcessedSource.new(source_code, RUBY_VERSION.to_f)
       raise WhatDyaReturn::SyntaxError unless processed.valid_syntax?
 
       Processor.new.process(processed.ast).map do |node|
         node.nil? ? 'nil' : Unparser.unparse(node)
-      end
+      end.uniq
     end
   end
 end

data/lib/what_dya_return/processor.rb

@@ -1,19 +1,40 @@
 # frozen_string_literal: true
 
-require_relative 'ext/rubocop/ast/builder'
-require_relative 'ext/rubocop/ast/node/if_node'
 require_relative 'statement_checker'
 
 module WhatDyaReturn
   class Processor
-    #
-    # @param [RuboCop::AST::DefNode] node
+    using NodeRefinary
+
+    # rubocop:disable Layout/HashAlignment
+    BRANCH_CHECKERS = {
+      WhatDyaReturn::AST::BeginNode  => :check_begin_node,
+      WhatDyaReturn::AST::ReturnNode => :check_return_node,
+      WhatDyaReturn::AST::IfNode     => :check_if_node,
+      WhatDyaReturn::AST::CaseNode   => :check_case_node,
+      WhatDyaReturn::AST::RescueNode => :check_rescue_node,
+      WhatDyaReturn::AST::EnsureNode => :check_ensure_node,
+      WhatDyaReturn::AST::WhileNode  => :check_while_node,
+      WhatDyaReturn::AST::UntilNode  => :check_until_node,
+      WhatDyaReturn::AST::ForNode    => :check_for_node,
+      WhatDyaReturn::AST::BreakNode  => :check_break_node,
+      WhatDyaReturn::AST::BlockNode  => :check_block_node,
+      WhatDyaReturn::AST::NextNode   => :check_next_node
+    }.freeze
+    # rubocop:enable Layout/HashAlignment
+
+    #
+    # @param [WhatDyaReturn::AST::DefNode] node
     # @return [Array<RuboCop::AST::Node>]
     #
     def process(node)
       @return_nodes = []
 
-      check_branch(node.body, true)
+      if node.body.nil? # `def foo; end`
+        @return_nodes << nil
+      else
+        check_branch(node.body, node)
+      end
 
       @return_nodes
     end
@@ -21,31 +42,22 @@ module WhatDyaReturn
     private
 
     #
-    # @param [RuboCop::AST::Node] node
-    # @param [Boolean] is_ret_expr Whether current scope is within return expression
+    # @param [RuboCop::AST::Node, nil] node
     # @return [void]
     #
-    def check_branch(node, is_ret_expr)
-      unless node
-        @return_nodes << node if is_ret_expr
+    def check_branch(node, parent)
+      if node.nil?
+        @return_nodes << node if parent.returnable_statement?
         return
       end
 
-      case node
-      when WhatDyaReturn::AST::BeginNode
-        check_begin_node(node, is_ret_expr)
-      when ::RuboCop::AST::ReturnNode
-        check_return_node(node)
-      when ::RuboCop::AST::IfNode
-        check_if_node(node, is_ret_expr)
-      when ::RuboCop::AST::CaseNode
-        check_case_node(node, is_ret_expr)
-      when ::RuboCop::AST::RescueNode
-        check_rescue_node(node, is_ret_expr)
-      when ::RuboCop::AST::EnsureNode
-        check_ensure_node(node, is_ret_expr)
+      if (checker = BRANCH_CHECKERS[node.class])
+        send(checker, node)
+      elsif node.is_a?(RuboCop::AST::Node)
+        @return_nodes << node if node.returnable_statement?
       else
-        @return_nodes << node if is_ret_expr
+        # For debug
+        raise UnintentionalNodeError, "Unknown node type: #{node.class}"
       end
     end
 
@@ -53,39 +65,37 @@ module WhatDyaReturn
     # @param [WhatDyaReturn::AST::BeginNode] node
     # @return [void]
     #
-    def check_begin_node(node, is_ret_expr)
+    def check_begin_node(node)
       node.children[0..-2].each do |child|
-        check_branch(child, false)
-        return unless StatementChecker.reachable_to_next_statement?(child) # rubocop:disable Lint/NonLocalExitFromIterator
+        check_branch(child, node)
+        return unless child.reachable_to_next_statement? # rubocop:disable Lint/NonLocalExitFromIterator
       end
 
-      check_branch(node.children[-1], is_ret_expr)
+      check_branch(node.children[-1], node)
     end
 
     #
-    # @param [RuboCop::AST::ReturnNode] node
+    # @param [WhatDyaReturn::AST::ReturnNode] node
     # @return [void]
     #
     def check_return_node(node)
-      check_branch(node.children.first, true)
+      check_branch(node.children.first, node)
     end
 
     #
-    # @param [RuboCop::AST::IfNode] node
-    # @param [Boolean] is_ret_expr Whether current scope is within return expression
+    # @param [WhatDyaReturn::AST::IfNode] node
     # @return [void]
     #
-    def check_if_node(node, is_ret_expr)
-      node.if_branch_reachable? && check_branch(node.if_branch, is_ret_expr)
-      node.else_branch_reachable? && check_branch(node.else_branch, is_ret_expr)
+    def check_if_node(node)
+      node.if_branch_reachable? && check_branch(node.if_branch, node)
+      node.else_branch_reachable? && check_branch(node.else_branch, node)
     end
 
     #
-    # @param [RuboCop::AST::CaseNode] node
-    # @param [Boolean] is_ret_expr Whether current scope is within return expression
+    # @param [WhatDyaReturn::AST::CaseNode] node
     # @return [void]
     #
-    def check_case_node(node, is_ret_expr)
+    def check_case_node(node)
       node.when_branches.each do |when_branch|
         #
         # case # no condition
@@ -97,40 +107,114 @@ module WhatDyaReturn
         #
         next if node.condition.nil? && when_branch.conditions.all?(&:falsey_literal?)
 
-        check_branch(when_branch.body, is_ret_expr)
+        check_branch(when_branch.body, when_branch)
       end
 
-      check_branch(node.else_branch, is_ret_expr)
+      check_branch(node.else_branch, node)
     end
 
     #
-    # @param [RuboCop::AST::RescueNode] node
-    # @param [Boolean] is_ret_expr Whether current scope is within return expression
+    # @param [WhatDyaReturn::AST::RescueNode] node
     # @return [void]
     #
-    def check_rescue_node(node, is_ret_expr)
-      if node.else_branch && StatementChecker.reachable_to_next_statement?(node.body)
-        check_branch(node.else_branch, is_ret_expr)
+    def check_rescue_node(node)
+      if node.else_branch && node.body.reachable_to_next_statement?
+        check_branch(node.else_branch, node)
       else
-        check_branch(node.body, is_ret_expr)
+        check_branch(node.body, node)
       end
 
       node.resbody_branches.each do |resbody_branch|
-        check_branch(resbody_branch.body, is_ret_expr)
+        check_branch(resbody_branch.body, resbody_branch)
+      end
+    end
+
+    #
+    # @param [WhatDyaReturn::AST::EnsureNode] node
+    # @return [void]
+    #
+    def check_ensure_node(node)
+      if node.body.reachable_to_next_statement?
+        check_branch(node.node_parts[0], node) # begin or rescue node
+      else
+        check_branch(node.body, node)
+      end
+    end
+
+    #
+    # @param [WhatDyaReturn::AST::WhileNode] node
+    # @return [void]
+    #
+    def check_while_node(node)
+      if node.body_reachable?
+        check_branch(node.body, node)
+        check_branch(nil, node) if node.body.reachable_to_next_statement?
+      else
+        check_branch(nil, node)
       end
     end
 
     #
-    # @param [RuboCop::AST::EnsureNode] node
-    # @param [Boolean] is_ret_expr Whether current scope is within return expression
+    # @param [WhatDyaReturn::AST::UntilNode] node
     # @return [void]
     #
-    def check_ensure_node(node, is_ret_expr)
-      if StatementChecker.reachable_to_next_statement?(node.body)
-        check_branch(node.node_parts[0], is_ret_expr) # begin or rescue node
+    def check_until_node(node)
+      if node.body_reachable?
+        check_branch(node.body, node)
+        check_branch(nil, node) if node.body.reachable_to_next_statement?
       else
-        check_branch(node.body, false)
+        check_branch(nil, node)
       end
     end
+
+    #
+    # @param [WhatDyaReturn::AST::ForNode] node
+    # @return [void]
+    #
+    def check_for_node(node)
+      check_branch(node.body, node)
+      check_branch(node.collection, node) if node.body.reachable_to_next_statement?
+    end
+
+    #
+    # @param [WhatDyaReturn::AST::BreakNode] node
+    # @return [void]
+    #
+    def check_break_node(node)
+      check_branch(node.children.first, node)
+    end
+
+    #
+    # @param [WhatDyaReturn::AST::BlockNode] node
+    # @return [void]
+    #
+    def check_block_node(node)
+      check_branch(node.body, node)
+      check_branch(node.send_node, node) if node.body.reachable_to_next_statement?
+    end
+
+    #
+    # @note The value passed to `next` is not used for the return value of `block`.
+    #
+    # @example
+    #
+    #   def foo
+    #     10.times do |i|
+    #       next 42 if i == 2
+    #     end
+    #   end
+    #
+    #   foo => # 10.times
+    #
+    #
+    # @param [WhatDyaReturn::AST::NextNode] node
+    # @return [void]
+    #
+    def check_next_node(node)
+      block_node = node.ancestors.find { |n| n.instance_of?(AST::BlockNode) }
+      return if block_node.nil?
+
+      check_branch(block_node.send_node, node)
+    end
   end
 end

data/lib/what_dya_return/statement_checker/reachable_to_next_statement.rb

@@ -8,8 +8,21 @@
 module WhatDyaReturn
   module StatementChecker
     class ReachableToNextStatement
+      extend RuboCop::AST::NodePattern::Macros
+
+      # @!method flow_terminate_command?(node)
+      def_node_matcher :flow_terminate_command?, <<~PATTERN
+        {
+          return next break retry redo
+          (send
+            {nil? (const {nil? cbase} :Kernel)}
+            {:raise :fail :throw :exit :exit! :abort}
+            ...)
+        }
+      PATTERN
+
       #
-      # @param node [::RuboCop::AST::Node]
+      # @param node [RuboCop::AST::Node]
       # @return [Boolean]
       #
       def ok?(node)
@@ -18,9 +31,9 @@ module WhatDyaReturn
         case node
         when WhatDyaReturn::AST::BeginNode
           check_begin(node)
-        when ::RuboCop::AST::IfNode
+        when WhatDyaReturn::AST::IfNode
           check_if(node)
-        when ::RuboCop::AST::CaseNode
+        when WhatDyaReturn::AST::CaseNode
           check_case(node)
         else
           true
@@ -88,7 +101,7 @@ module WhatDyaReturn
       #
       #    "b" # unreachable
       #
-      # @param node [::RuboCop::AST::IfNode]
+      # @param node [WhatDyaReturn::AST::IfNode]
       # @return [Boolean]
       #
       def check_if(node)
@@ -129,7 +142,7 @@ module WhatDyaReturn
       #
       #    "b" # unreachable
       #
-      # @param node [::RuboCop::AST::CaseNode]
+      # @param node [WhatDyaReturn::AST::CaseNode]
       # @return [Boolean]
       #
       def check_case(node)
@@ -138,22 +151,6 @@ module WhatDyaReturn
 
         node.when_branches.any? { |when_branch| ok?(when_branch.body) }
       end
-
-      #
-      # @param node [::RuboCop::AST::Node]
-      # @return [Boolean]
-      #
-      def flow_terminate_command?(node)
-        ::RuboCop::AST::NodePattern.new(<<-PATTERN).match(node)
-          {
-            return next break retry redo
-            (send
-              {nil? (const {nil? cbase} :Kernel)}
-              {:raise :fail :throw :exit :exit! :abort}
-              ...)
-          }
-        PATTERN
-      end
     end
   end
 end

data/lib/what_dya_return/statement_checker/returnable_statement.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module WhatDyaReturn
+  module StatementChecker
+    class ReturnableStatement
+      # rubocop:disable Layout/HashAlignment
+      USED_CHECKERS = {
+        AST::ReturnNode => :return_node_used?,
+        AST::DefNode    => :def_node_used?,
+        AST::BeginNode  => :begin_node_used?,
+        AST::BreakNode  => :break_node_used?,
+        AST::WhileNode  => :while_until_node_used?,
+        AST::UntilNode  => :while_until_node_used?,
+        AST::ForNode    => :for_node_used?,
+        AST::BlockNode  => :block_node_used?
+      }.freeze
+      # rubocop:enable Layout/HashAlignment
+
+      #
+      # Inspired by RuboCop::AST::Node#value_used?
+      #
+      def ok?(node)
+        return false if node.parent.nil?
+
+        if (checker = USED_CHECKERS[node.parent.class])
+          send(checker, node)
+        else
+          ok?(node.parent)
+        end
+      end
+
+      private
+
+      #
+      # @param [RuboCop::AST::Node] node
+      # @return [Boolean]
+      #
+      def return_node_used?(_node)
+        true
+      end
+
+      #
+      # @param [RuboCop::AST::Node] node
+      # @return [Boolean]
+      #
+      def def_node_used?(node)
+        node.sibling_index == node.parent.children.size - 1
+      end
+
+      #
+      # @example
+      #
+      #   def foo
+      #     begin
+      #       1 # false
+      #       2 # true
+      #     end
+      #   end
+      #
+      #   foo # => 2
+      #
+      # @example
+      #
+      #   def foo
+      #     begin
+      #       1 # false
+      #       2 # false
+      #     end
+      #
+      #     begin
+      #       3 # false
+      #       4 # true
+      #     end
+      #   end
+      #
+      #   foo # => 4
+      #
+      # @param [RuboCop::AST::Node] node
+      # @return [Boolean]
+      #
+      def begin_node_used?(node)
+        node.sibling_index == node.parent.children.size - 1 ? ok?(node.parent) : false
+      end
+
+      #
+      # @example
+      #
+      #   def foo
+      #     while bar
+      #       break 1 if baz
+      #     end
+      #
+      #     while qux
+      #       break 2 if quux
+      #     end
+      #   end
+      #
+      #   foo # => 2
+      #
+      # @param [RuboCop::AST::Node] node
+      # @return [Boolean]
+      #
+      def break_node_used?(node)
+        ancestor = node.ancestors.find do |n|
+          [AST::WhileNode, AST::UntilNode, AST::ForNode, AST::BlockNode].include?(n.class)
+        end
+
+        ok?(ancestor)
+      end
+
+      #
+      # Only with break or return node.
+      #
+      # @example
+      #
+      #   value = while foo
+      #             1 # false
+      #             return 2 if bar
+      #             break 3 if baz
+      #             4 # false
+      #           end
+      #
+      #   value # => 2 or 3
+      #
+      # @param [RuboCop::AST::Node] node
+      # @return [Boolean]
+      #
+      def while_until_node_used?(_node)
+        false
+      end
+
+      #
+      # value = for variable in collection
+      #           body
+      #         end
+      #
+      # value == collection # => true
+      #
+      # @param [RuboCop::AST::Node] node
+      # @return [Boolean]
+      #
+      def for_node_used?(node)
+        node.parent.collection == node ? ok?(node.parent) : false
+      end
+
+      #
+      # [1, 2, 3].each do |n| # send_node == [1, 2, 3].each
+      #   p n
+      # end
+      #
+      # @param [RuboCop::AST::Node] node
+      # @return [Boolean]
+      #
+      def block_node_used?(node)
+        node.parent.send_node == node ? ok?(node.parent) : false
+      end
+    end
+  end
+end

data/lib/what_dya_return/statement_checker.rb

@@ -1,9 +1,19 @@
 # frozen_string_literal: true
 
 require_relative 'statement_checker/reachable_to_next_statement'
+require_relative 'statement_checker/returnable_statement'
 
 module WhatDyaReturn
   module StatementChecker
+    #
+    # @param node [::RuboCop::AST::Node]
+    # @return [Boolean]
+    #
+    def self.returnable_statement?(node)
+      @returnable_statement ||= ReturnableStatement.new
+      @returnable_statement.ok?(node)
+    end
+
     #
     # @param node [::RuboCop::AST::Node]
     # @return [Boolean]

data/lib/what_dya_return/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module WhatDyaReturn
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/lib/what_dya_return.rb

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
 
+require_relative 'what_dya_return/ast'
 require_relative 'what_dya_return/extractor'
 require_relative 'what_dya_return/version'
 
 module WhatDyaReturn
   class Error < StandardError; end
   class SyntaxError < Error; end
+  class UnintentionalNodeError < Error; end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: what_dya_return
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Wataru MIYAGUNI
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-07-19 00:00:00.000000000 Z
+date: 2023-08-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop-ast
@@ -52,13 +52,32 @@ files:
 - README.md
 - Rakefile
 - lib/what_dya_return.rb
+- lib/what_dya_return/ast.rb
+- lib/what_dya_return/ast/builder.rb
+- lib/what_dya_return/ast/node.rb
+- lib/what_dya_return/ast/node/array_node.rb
 - lib/what_dya_return/ast/node/begin_node.rb
-- lib/what_dya_return/ext/rubocop/ast/builder.rb
-- lib/what_dya_return/ext/rubocop/ast/node/if_node.rb
+- lib/what_dya_return/ast/node/block_node.rb
+- lib/what_dya_return/ast/node/break_node.rb
+- lib/what_dya_return/ast/node/case_node.rb
+- lib/what_dya_return/ast/node/def_node.rb
+- lib/what_dya_return/ast/node/ensure_node.rb
+- lib/what_dya_return/ast/node/for_node.rb
+- lib/what_dya_return/ast/node/if_node.rb
+- lib/what_dya_return/ast/node/next_node.rb
+- lib/what_dya_return/ast/node/resbody_node.rb
+- lib/what_dya_return/ast/node/rescue_node.rb
+- lib/what_dya_return/ast/node/return_node.rb
+- lib/what_dya_return/ast/node/until_node.rb
+- lib/what_dya_return/ast/node/when_node.rb
+- lib/what_dya_return/ast/node/while_node.rb
+- lib/what_dya_return/ast/processed_source.rb
+- lib/what_dya_return/ext/rubocop-ast/node.rb
 - lib/what_dya_return/extractor.rb
 - lib/what_dya_return/processor.rb
 - lib/what_dya_return/statement_checker.rb
 - lib/what_dya_return/statement_checker/reachable_to_next_statement.rb
+- lib/what_dya_return/statement_checker/returnable_statement.rb
 - lib/what_dya_return/version.rb
 - sig/what_dya_return.rbs
 homepage: https://github.com/gongo/what_dya_return
@@ -83,7 +102,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.33
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: Predict Ruby code return values.

data/lib/what_dya_return/ext/rubocop/ast/builder.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../../ast/node/begin_node'
-
-module RuboCop
-  module AST
-    class Builder
-      EXT_NODE_MAP = NODE_MAP.merge(
-        {
-          begin: WhatDyaReturn::AST::BeginNode,
-          kwbegin: WhatDyaReturn::AST::BeginNode
-        }
-      )
-
-      #
-      # @override
-      #
-      def node_klass(type)
-        EXT_NODE_MAP.fetch(type, ::RuboCop::AST::Node)
-      end
-    end
-  end
-end