deep-cover-core 0.6.3.pre

data/lib/deep_cover/node/assignments.rb

@@ -0,0 +1,273 @@
+# frozen_string_literal: true
+
+require_relative 'const'
+require_relative 'literals'
+require_relative 'keywords'
+
+module DeepCover
+  class Node
+    class VariableAssignment < Node
+      has_child var_name: Symbol
+      has_child value: [Node, nil]
+      executed_loc_keys :name, :operator
+
+      def execution_count
+        return super unless value
+        value.flow_completion_count
+      end
+    end
+    Cvasgn = Gvasgn = Ivasgn = Lvasgn = VariableAssignment
+
+    class Casgn < Node
+      has_child cbase: [Cbase, Const, nil, Self, Begin, Kwbegin]
+      has_child var_name: Symbol
+      has_child value: [Node, nil]
+
+      def execution_count
+        return super unless value
+        value.flow_completion_count
+      end
+    end
+
+    class Mlhs < Node
+      has_extra_children being_set: Node
+      # TODO
+    end
+
+    module BackwardsStrategy
+      # Instead of assuming our parent tracks our entry and we are responsible
+      # for tracking our completion, we go the other way and assume our parent
+      # tracks our completion and we are responsible for our entry.
+      def flow_completion_count
+        if (s = next_sibling)
+          s.flow_entry_count
+        else
+          parent.flow_completion_count
+        end
+      end
+
+      def flow_entry_count
+        if (first_child = children_nodes.first)
+          first_child.flow_entry_count
+        else
+          flow_completion_count
+        end
+      end
+    end
+
+    # Some multiple assignments are the only cases where Ruby
+    # syntax rules won't allow us to insert tracking code
+    # where we'd like it to be run.
+    #
+    # For example:
+    #
+    #   method.a, b, method_2.c = [...]
+    #
+    # We'd like to add a tracker after the call to `a=` and
+    # before the assignment to b and the call to `method_2`.
+    #
+    # We can't really do this with simple insertions, so
+    # we temporarily of strategy for BackwardsStrategy
+    #
+    class Masgn < Node
+      class BackwardsNode < Node
+        include BackwardsStrategy
+      end
+
+      # We can't rewrite `self.bar` within a multiple assignment in the
+      # case that `bar=` is private, so remain conservative and don't add
+      # trackers.
+      class SelfReceiver < BackwardsNode
+        executed_loc_keys :expression
+      end
+
+      class ConstantCbase < BackwardsNode
+      end
+
+      class DynamicReceiverWrap < Node
+        include Wrapper
+        has_tracker :entry
+        has_child actual_receiver: Node
+        def rewrite
+          '(%{entry_tracker};%{node})'
+        end
+        alias_method :flow_entry_count, :entry_tracker_hits
+      end
+
+      class Setter < Node
+        include BackwardsStrategy
+        has_child receiver: {self: SelfReceiver, Parser::AST::Node => DynamicReceiverWrap}
+        has_child method_name: Symbol
+        has_child arg: [Node, nil] # When method is :[]=
+        executed_loc_keys :dot, :selector_begin, :selector_end
+
+        def loc_hash
+          base = super
+          if method_name == :[]=
+            selector = base[:selector]
+            {
+              expression: base[:expression],
+              selector_begin: selector.resize(1),
+              # The = is implicit, so only backtrack the end by one
+              selector_end: Parser::Source::Range.new(selector.source_buffer, selector.end_pos - 1, selector.end_pos),
+            }
+          else
+            {
+              dot: base[:dot],
+              expression: base[:expression],
+              selector_begin: base[:selector],
+              selector_end: nil, # ,
+            }
+          end
+        end
+
+        def execution_count
+          receiver.flow_completion_count
+        end
+      end
+
+      class ConstantScopeWrapper < Node
+        include Wrapper
+        has_tracker :entry
+        has_child actual_node: Node
+
+        def rewrite
+          '(%{entry_tracker};%{node})'
+        end
+
+        def flow_entry_count
+          entry_tracker_hits
+        end
+      end
+
+      class ConstantAssignment < Node
+        include BackwardsStrategy
+        has_child scope: [nil], remap: {cbase: ConstantCbase, Parser::AST::Node => ConstantScopeWrapper}
+        has_child constant_name: Symbol
+
+        def execution_count
+          scope ? scope.flow_completion_count : super
+        end
+      end
+
+      class VariableAssignment < Node
+        include BackwardsStrategy
+        has_child var_name: Symbol
+      end
+
+      BASE_MAP = {
+                   cvasgn: VariableAssignment, gvasgn: VariableAssignment,
+                   ivasgn: VariableAssignment, lvasgn: VariableAssignment,
+                   casgn: ConstantAssignment,
+                   send: Setter,
+                 }.freeze
+      class Splat < Node
+        include BackwardsStrategy
+        has_child rest_arg: [nil], remap: BASE_MAP
+        executed_loc_keys :operator
+      end
+
+      class LeftSide < Node
+        include BackwardsStrategy
+        has_extra_children receivers: {
+                                        splat: Splat,
+                                        mlhs: LeftSide,
+                                        **BASE_MAP,
+                                      }
+        executed_loc_keys # none
+
+        def flow_completion_count
+          parent.flow_completion_count
+        end
+      end
+
+      check_completion
+
+      has_child left: {mlhs: LeftSide}
+      has_child value: Node
+
+      executed_loc_keys :operator
+
+      def execution_count
+        value.flow_completion_count
+      end
+
+      def children_nodes_in_flow_order
+        [value, left]
+      end
+    end
+
+    class VariableOperatorAssign < Node
+      has_child var_name: Symbol
+    end
+
+    class ConstantOperatorAssign < Node
+      has_child scope: [Node, nil]
+      has_child const_name: Symbol
+      def execution_count
+        flow_completion_count
+      end
+    end
+
+    class SendOperatorAssign < Node
+      has_child receiver: [Node, nil]
+      has_child method_name: Symbol
+      has_extra_children arguments: Node
+      executed_loc_keys :dot, :selector_begin, :selector_end, :operator
+
+      def loc_hash
+        base = super
+        hash = {expression: base[:expression], begin: base[:begin], end: base[:end], dot: base[:dot]}
+        selector = base[:selector]
+
+        if [:[], :[]=].include?(method_name)
+          hash[:selector_begin] = selector.resize(1)
+          hash[:selector_end] = Parser::Source::Range.new(selector.source_buffer, selector.end_pos - 1, selector.end_pos)
+        else
+          hash[:selector_begin] = base[:selector]
+        end
+
+        hash
+      end
+    end
+
+    # foo += bar
+    class OpAsgn < Node
+      check_completion
+      has_tracker :reader
+      has_child receiver: {
+                            lvasgn: VariableOperatorAssign, ivasgn: VariableOperatorAssign,
+                            cvasgn: VariableOperatorAssign, gvasgn: VariableOperatorAssign,
+                            casgn: Casgn, # TODO
+                            send: SendOperatorAssign,
+                          }
+      has_child operator: Symbol
+      has_child value: Node, rewrite: '(%{reader_tracker};%{node})', flow_entry_count: :reader_tracker_hits
+      executed_loc_keys :operator
+
+      def execution_count
+        flow_completion_count
+      end
+    end
+
+    # foo ||= bar, foo &&= base
+    class BooleanAssignment < Node
+      check_completion
+      has_tracker :long_branch
+      has_child receiver: {
+                            lvasgn: VariableOperatorAssign, ivasgn: VariableOperatorAssign,
+                            cvasgn: VariableOperatorAssign, gvasgn: VariableOperatorAssign,
+                            casgn: ConstantOperatorAssign,
+                            send: SendOperatorAssign,
+                          }
+      has_child value: Node, rewrite: '(%{long_branch_tracker};%{node})', flow_entry_count: :long_branch_tracker_hits
+      executed_loc_keys :operator
+
+      def execution_count
+        flow_completion_count
+      end
+    end
+
+    OrAsgn = AndAsgn = BooleanAssignment
+  end
+end

data/lib/deep_cover/node/base.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+module DeepCover
+  # Base class to handle covered nodes.
+  class Node
+    include Mixin
+    include HasTracker
+    include HasChild
+    include HasChildHandler
+    include CanAugmentChildren
+    include Rewriting
+    extend CheckCompletion
+    include FlowAccounting
+    include IsStatement
+    include ExecutionLocation
+    include ChildCanBeEmpty
+    include Filters
+    extend Filters::ClassMethods
+
+    attr_reader :index, :parent, :children, :base_node
+
+    def initialize(base_node, parent:, index: 0, base_children: base_node.children)
+      @base_node = base_node
+      @parent = parent
+      @index = index
+      @children = []
+      begin
+        @children = augment_children(base_children)
+        initialize_siblings
+        super()
+      rescue StandardError => e
+        diagnose(e)
+      end
+    end
+
+    ### Public API
+
+    # Search self and descendants for a particular Class or type
+    def find_all(lookup)
+      case lookup
+      when ::Module
+        each_node.grep(lookup)
+      when ::Symbol
+        each_node.find_all { |n| n.type == lookup }
+      when ::String
+        each_node.find_all { |n| n.source == lookup }
+      when ::Regexp
+        each_node.find_all { |n| n.source =~ lookup }
+      else
+        raise ::TypeError, "Expected class or symbol, got #{lookup.class}: #{lookup.inspect}"
+      end
+    end
+
+    # Shortcut to access children
+    def [](lookup)
+      if lookup.is_a?(Integer)
+        children.fetch(lookup)
+      else
+        found = find_all(lookup)
+        case found.size
+        when 1
+          found.first
+        when 0
+          raise "No children of type #{lookup}"
+        else
+          raise "Ambiguous lookup #{lookup}, found #{found}."
+        end
+      end
+    end
+
+    # Shortcut to create a node from source code
+    def self.[](source)
+      CoveredCode.new(source: source).execute_code.covered_ast
+    end
+
+    def children_nodes
+      children.select { |c| c.is_a? Node }
+    end
+    alias_method :children_nodes_in_flow_order, :children_nodes
+
+    attr_accessor :next_sibling
+    attr_accessor :previous_sibling
+    protected :next_sibling=, :previous_sibling=
+    def initialize_siblings
+      children_nodes_in_flow_order.each_cons(2) do |child, next_child|
+        child.next_sibling = next_child
+        next_child.previous_sibling = child
+      end
+    end
+    private :initialize_siblings
+
+    # Adapted from https://github.com/whitequark/ast/blob/master/lib/ast/node.rb
+    def to_s(indent = 0)
+      [
+        '  ' * indent,
+        '(',
+        fancy_type,
+        *children.map do |child, idx|
+          if child.is_a?(Node)
+            "\n#{child.to_s(indent + 1)}"
+          else
+            " #{child.inspect}"
+          end
+        end,
+        ')',
+      ].join
+    end
+
+    alias_method :inspect, :to_s
+    ### Internal API
+
+    def covered_code
+      parent.covered_code
+    end
+
+    def type
+      return base_node.type if base_node.respond_to? :type
+      self.class.name.split('::').last.to_sym
+    end
+
+    def each_node(order = :postorder, &block)
+      return to_enum :each_node, order unless block_given?
+      yield self unless order == :postorder
+      children_nodes.each do |child|
+        child.each_node(order, &block)
+      end
+      yield self if order == :postorder
+      self
+    end
+
+    def fancy_type
+      class_name = self.class.to_s.gsub(/^DeepCover::/, '').gsub(/^Node::/, '')
+      t = type.to_s
+      t.casecmp(class_name) == 0 ? t : "#{t}[#{class_name}]"
+    end
+
+    private
+
+    def diagnose(exception)
+      msg = if self.class == Node
+              "Unknown node type encountered: #{base_node.type}"
+            else
+              "Node class #{self.class} incorrectly defined"
+            end
+      warn [msg,
+            'Attempting to continue, but this node will not be handled properly',
+            ('Its subnodes will be ignored' if children.empty?),
+            'Source:',
+            expression,
+            'Original exception:',
+            exception.inspect,
+      ].join("\n")
+    end
+  end
+end

data/lib/deep_cover/node/begin.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module DeepCover
+  class Node
+    class Begin < Node
+      has_extra_children expressions: Node,
+                         is_statement: true
+
+      def is_statement
+        false
+      end
+
+      def executed_loc_keys
+        # Begin is a generic grouping used in different contexts.
+        case loc_hash[:begin] && loc_hash[:begin].source
+        when nil, '(', 'begin'
+          []
+        when 'else', '#{'
+          %i[begin end]
+        else
+          warn 'Unknown context for Begin node'
+          []
+        end
+      end
+    end
+  end
+end

data/lib/deep_cover/node/block.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative 'send'
+require_relative 'keywords'
+
+module DeepCover
+  class Node
+    module WithBlock
+      def flow_completion_count
+        parent.flow_completion_count
+      end
+
+      def execution_count
+        last = children_nodes.last
+        return last.flow_completion_count if last
+        super
+      end
+    end
+
+    class SendWithBlock < SendBase
+      include WithBlock
+    end
+
+    class SuperWithBlock < Node
+      include WithBlock
+      has_extra_children arguments: Node
+    end
+
+    class Block < Node
+      check_completion
+      has_tracker :body
+      has_child call: {send: SendWithBlock, zsuper: SuperWithBlock, super: SuperWithBlock, csend: Csend}
+      has_child args: Args
+      has_child body: Node,
+                can_be_empty: -> { base_node.loc.end.begin },
+                rewrite: '%{body_tracker};%{local}=nil;%{node}',
+                flow_entry_count: :body_tracker_hits,
+                is_statement: true
+      executed_loc_keys # none
+
+      def children_nodes_in_flow_order
+        [call, args] # Similarly to a def, the body is actually not part of the flow of this node...
+      end
+
+      alias_method :rewrite_for_completion, :rewrite
+      def rewrite
+        if call.is_a?(Csend)
+          rewrite_for_completion.gsub('%{node}', Csend::REWRITE_SUFFIX)
+        else
+          rewrite_for_completion
+        end
+      end
+    end
+
+    # &foo
+    class BlockPass < Node
+      has_child block: Node
+      # TODO
+    end
+  end
+end

data/lib/deep_cover/node/branch.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative 'empty_body'
+
+module DeepCover
+  class Node
+    module Branch
+      def flow_completion_count
+        branches.map(&:flow_completion_count).inject(0, :+)
+      end
+
+      # Define in sublasses:
+      def branches
+        raise NotImplementedError
+      end
+
+      # Also define flow_entry_count
+    end
+
+    class TrivialBranch < Node::EmptyBody
+      def initialize(other_branch:, condition:, position: true)
+        @condition = condition
+        @other_branch = other_branch
+        super(nil, parent: condition.parent, position: position)
+      end
+
+      def flow_entry_count
+        @condition.flow_completion_count - @other_branch.flow_entry_count
+      end
+    end
+  end
+end

data/lib/deep_cover/node/case.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require_relative 'branch'
+
+module DeepCover
+  class Node
+    class WhenCondition < Node
+      include Wrapper
+      has_tracker :entry
+      # Using && instead of ; solves a weird bug in jruby 9.1.7.0 and 9.1.9.0 (probably before too).
+      # The following will only print 'test' once
+      #    class EqEqEq; def ===(other); puts 'test'; end; end
+      #    eqeqeq = EqEqEq.new
+      #    case 1; when eqeqeq; end
+      #    case 1; when (3;eqeqeq); end
+      # See https://github.com/jruby/jruby/issues/4804
+      # This is solved in jruby 9.2.0.0, better keep the workaround
+      # for compatibility.
+      has_child condition: Node, rewrite: '((%{entry_tracker}) && %{node})',
+                flow_entry_count: :entry_tracker_hits
+      executed_loc_keys []
+
+      def flow_entry_count
+        entry_tracker_hits
+      end
+
+      def flow_completion_count
+        condition.flow_completion_count
+      end
+
+      def loc_hash
+        condition.loc_hash
+      end
+    end
+
+    class WhenSplatCondition < Node
+      has_tracker :entry
+      check_completion inner: '(%{entry_tracker};[%{node}])', outer: '*%{node}'
+      has_child receiver: Node
+
+      def flow_entry_count
+        entry_tracker_hits
+      end
+    end
+
+    class When < Node
+      has_tracker :body_entry
+      has_extra_children matches: {splat: WhenSplatCondition, Parser::AST::Node => WhenCondition}
+      has_child body: Node,
+                can_be_empty: -> {
+                                if (after_then = base_node.loc.begin)
+                                  after_then.end
+                                else
+                                  base_node.loc.expression.end.succ
+                                end
+                              },
+                rewrite: '%{body_entry_tracker};%{local}=nil;%{node}',
+                is_statement: true,
+                flow_entry_count: :body_entry_tracker_hits
+
+      def flow_entry_count
+        matches.first.flow_entry_count
+      end
+
+      def execution_count
+        matches.first.flow_completion_count
+      end
+
+      def flow_completion_count
+        body.flow_completion_count + next_sibling.flow_entry_count
+      end
+    end
+
+    class Case < Node
+      include Branch
+      has_tracker :else_entry
+      has_child evaluate: [Node, nil]
+      has_extra_children whens: When
+      has_child else: Node,
+                can_be_empty: -> { base_node.loc.end.begin },
+                rewrite: -> { "#{'else;' unless has_else?}(%{else_entry_tracker};%{local}=nil;%{node})" },
+                executed_loc_keys: [:else],
+                is_statement: true,
+                flow_entry_count: :else_entry_tracker_hits
+
+      executed_loc_keys :begin, :keyword
+
+      def branches
+        whens.map(&:body) << self.else
+      end
+
+      def branches_summary(of_branches = branches)
+        texts = []
+        n = of_branches.size
+        if of_branches.include? self.else
+          texts << "#{'implicit ' unless has_else?}else"
+          n -= 1
+        end
+        texts.unshift "#{n} when clause#{'s' if n > 1}" if n > 0
+        texts.join(' and ')
+      end
+
+      def execution_count
+        return evaluate.flow_completion_count if evaluate
+        flow_entry_count
+      end
+
+      def has_else?
+        !!base_node.loc.to_hash[:else]
+      end
+    end
+  end
+end

data/lib/deep_cover/node/collections.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative 'splat'
+
+module DeepCover
+  class Node
+    module SimpleIfEmpty
+      def simple_literal?
+        children.empty?
+      end
+    end
+
+    class Array < Node
+      include SimpleIfEmpty
+      has_extra_children elements: Node
+      executed_loc_keys :begin, :end
+    end
+
+    class Pair < Node
+      has_child key: Node
+      has_child value: Node
+      executed_loc_keys :operator
+    end
+
+    class Hash < Node
+      include SimpleIfEmpty
+      has_extra_children elements: [Pair, Kwsplat]
+      executed_loc_keys :begin, :end
+    end
+  end
+end

data/lib/deep_cover/node/const.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module DeepCover
+  class Node::Const < Node
+    check_completion
+    has_child scope: [Node, nil]
+    has_child const_name: Symbol
+  end
+
+  class Node::Cbase < Node
+  end
+end