deep-cover-core 0.6.3.pre

data/lib/deep_cover/node/def.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative 'arguments'
+
+module DeepCover
+  class Node::Def < Node
+    check_completion
+    has_tracker :method_call
+    has_child method_name: Symbol
+    has_child signature: Args
+    has_child body: Node,
+              rewrite: '%{method_call_tracker};%{local}=nil;%{node}',
+              can_be_empty: -> { base_node.loc.end.begin },
+              is_statement: true,
+              flow_entry_count: :method_call_tracker_hits
+    executed_loc_keys :keyword, :name
+
+    def children_nodes_in_flow_order
+      []
+    end
+  end
+
+  class Node::Defs < Node
+    check_completion
+    has_tracker :method_call
+    has_child singleton: Node, rewrite: '(%{node})'
+    has_child method_name: Symbol
+    has_child signature: Args
+    has_child body: Node,
+              rewrite: '%{method_call_tracker};%{local}=nil;%{node}',
+              can_be_empty: -> { base_node.loc.end.begin },
+              is_statement: true,
+              flow_entry_count: :method_call_tracker_hits
+    executed_loc_keys :keyword, :name, :operator
+
+    def children_nodes_in_flow_order
+      [singleton]
+    end
+  end
+end

data/lib/deep_cover/node/empty_body.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module DeepCover
+  class Node::EmptyBody < Node
+    def initialize(base_node, parent:, index: 0, position: ChildCanBeEmpty.last_empty_position)
+      @position = position
+      super(base_node, parent: parent, index: index, base_children: [])
+    end
+
+    def type
+      :EmptyBody
+    end
+
+    def loc_hash
+      return {} if @position == true
+      {expression: @position}
+    end
+
+    def is_statement
+      false
+    end
+
+    # When parent rewrites us, the %{node} must always be at the beginning because our location can
+    # also be rewritten by out parent, and we want the rewrite to be after it.
+    def rewriting_rules
+      rules = super
+      rules.map do |expression, rule|
+        [expression, "%{node};#{rule.sub('%{node}', 'nil;')}"]
+      end
+    end
+  end
+end

data/lib/deep_cover/node/exceptions.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require_relative 'variables'
+require_relative 'collections'
+
+module DeepCover
+  class Node
+    class Resbody < Node
+      has_tracker :entered_body
+      has_child exception: [Node::Array, nil]
+      has_child assignment: [Lvasgn, nil], flow_entry_count: :entered_body_tracker_hits
+      has_child body: Node,
+                can_be_empty: -> { (base_node.loc.begin || base_node.loc.expression.succ).end },
+                flow_entry_count: :entered_body_tracker_hits,
+                is_statement: true,
+                rewrite: '(%{entered_body_tracker};%{local}=nil;%{node})'
+
+      def is_statement
+        false
+      end
+
+      def execution_count
+        entered_body_tracker_hits
+      end
+    end
+
+    class Rescue < Node
+      has_child watched_body: Node,
+                can_be_empty: -> { base_node.loc.expression.begin },
+                is_statement: true
+      has_extra_children resbodies: Resbody
+      has_child else: Node,
+                can_be_empty: -> { base_node.loc.expression.end },
+                flow_entry_count: :execution_count,
+                is_statement: true
+      executed_loc_keys :else
+
+      def is_statement
+        false
+      end
+
+      def flow_completion_count
+        resbodies.map(&:flow_completion_count).inject(0, :+) + self.else.flow_completion_count
+      end
+
+      def execution_count
+        watched_body.flow_completion_count
+      end
+
+      def resbodies_flow_entry_count(child)
+        prev = child.previous_sibling
+
+        if prev.equal? watched_body
+          prev.flow_entry_count - prev.flow_completion_count
+        else # RESBODIES
+          if prev.exception # rubocop:disable Style/IfInsideElse
+            prev.exception.flow_completion_count - prev.execution_count
+          else
+            prev.flow_entry_count - prev.execution_count
+          end
+        end
+      end
+    end
+
+    class Ensure < Node
+      has_child body: Node,
+                can_be_empty: -> { base_node.loc.expression.begin },
+                is_statement: true
+      has_child ensure: Node,
+                can_be_empty: -> { base_node.loc.expression.end.succ },
+                is_statement: true,
+                flow_entry_count: -> { body.flow_entry_count }
+
+      def flow_completion_count
+        body.flow_completion_count
+      end
+    end
+  end
+end

data/lib/deep_cover/node/if.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require_relative 'branch'
+
+module DeepCover
+  class Node
+    class If < Node
+      include Branch
+      has_tracker :truthy
+      has_child condition: Node, rewrite: '((%{node}) && %{truthy_tracker})'
+      has_child true_branch: Node,
+                executed_loc_keys: -> { :else if style == :unless },
+                flow_entry_count: :truthy_tracker_hits,
+                is_statement: true
+      has_child false_branch: Node,
+                executed_loc_keys: -> { [:else, :colon] if style != :unless },
+                flow_entry_count: -> { condition.flow_completion_count - truthy_tracker_hits },
+                is_statement: true
+      executed_loc_keys :keyword, :question
+
+      def child_can_be_empty(child, name)
+        return false if name == :condition || style == :ternary
+        if (name == :true_branch) == [:if, :elsif].include?(style)
+          (base_node.loc.begin || base_node.children[0].loc.expression.succ).end
+        elsif has_else?
+          base_node.loc.else.end.succ
+        else
+          true # implicit else
+        end
+      end
+
+      def branches
+        [true_branch, false_branch]
+      end
+
+      def branches_summary(of_branches = branches)
+        of_branches.map do |jump|
+          "#{'implicit ' if jump.is_a?(EmptyBody) && !has_else?}#{jump == false_branch ? 'falsy' : 'truthy'} branch"
+        end.join(' and ')
+      end
+
+      def execution_count
+        condition.flow_completion_count
+      end
+
+      # returns on of %i[ternary if unless elsif]
+      def style
+        keyword = loc_hash[:keyword]
+        keyword ? keyword.source.to_sym : :ternary
+      end
+
+      def root_if_node
+        if style != :elsif
+          self
+        else
+          parent.root_if_node
+        end
+      end
+
+      def deepest_elsif_node
+        return if style != :elsif
+        return self if loc_hash[:else] && loc_hash[:else].source == 'else'
+        return self if false_branch.is_a?(EmptyBody)
+        false_branch.deepest_elsif_node
+      end
+
+
+      def has_else?
+        !!base_node.loc.to_hash[:else]
+      end
+    end
+  end
+end

data/lib/deep_cover/node/keywords.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require_relative 'variables'
+require_relative 'literals'
+
+module DeepCover
+  class Node
+    class Kwbegin < Node
+      has_extra_children instructions: Node,
+                         is_statement: true
+
+      def is_statement
+        false
+      end
+    end
+
+    class Return < Node
+      has_extra_children values: Node
+      # TODO
+    end
+
+    class Super < Node
+      check_completion
+      has_extra_children arguments: Node
+      # TODO
+    end
+    Zsuper = Super # Zsuper is super with no parenthesis (same arguments as caller)
+
+    class Yield < Node
+      has_extra_children arguments: Node
+      # TODO
+    end
+
+    class Break < Node
+      has_extra_children arguments: Node
+      # TODO: Anything special needed for the arguments?
+
+      def flow_completion_count
+        0
+      end
+    end
+
+    class Next < Node
+      has_extra_children arguments: Node
+      # TODO: Anything special needed for the arguments?
+
+      def flow_completion_count
+        0
+      end
+    end
+
+    class Alias < Node
+      check_completion
+      has_child alias: [Sym, Dsym, Gvar, BackRef]
+      has_child original: [Sym, Dsym, Gvar, BackRef]
+      # TODO: test
+    end
+
+    class NeverEvaluated < Node
+      has_extra_children whatever: [:any], remap: {Parser::AST::Node => NeverEvaluated}
+
+      def executable?
+        false
+      end
+    end
+
+    class Defined < Node
+      has_child code: {Parser::AST::Node => NeverEvaluated}
+      # TODO: test
+    end
+
+    class Undef < Node
+      check_completion
+      has_extra_children arguments: [Sym, Dsym]
+      # TODO: test
+    end
+
+    class Return < Node
+      include ExecutedAfterChildren
+
+      def flow_completion_count
+        0
+      end
+    end
+  end
+end

data/lib/deep_cover/node/literals.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require_relative 'begin'
+require_relative 'variables'
+require_relative 'collections'
+module DeepCover
+  class Node
+    def simple_literal?
+      false
+    end
+
+    class StaticLiteral < Node
+      executed_loc_keys :expression
+
+      def simple_literal?
+        true
+      end
+    end
+
+    # Singletons
+    class SingletonLiteral < StaticLiteral
+    end
+    True = False = Nil = Self = SingletonLiteral
+
+    # Atoms
+    def self.atom(type)
+      ::Class.new(StaticLiteral) do
+        has_child value: type
+      end
+    end
+    Sym = atom(::Symbol)
+    Int = atom(::Integer)
+    Float = atom(::Float)
+    Complex = atom(::Complex)
+    Rational = atom(::Rational)
+    class Regopt < StaticLiteral
+      has_extra_children options: [::Symbol]
+    end
+
+    class Str < StaticLiteral
+      has_child value: ::String
+
+      def executed_loc_keys
+        keys = [:expression, :heredoc_body, :heredoc_end]
+
+        exp = expression
+        keys.delete(:expression) if exp && exp.source !~ /\S/
+
+        hd_body = loc_hash[:heredoc_body]
+        keys.delete(:heredoc_body) if hd_body && hd_body.source !~ /\S/
+
+        keys
+      end
+    end
+
+    # (Potentially) dynamic
+    module SimpleIfItsChildrenAre
+      def simple_literal?
+        children.all?(&:simple_literal?)
+      end
+    end
+
+    # Di-atomic
+    class Range < Node
+      include SimpleIfItsChildrenAre
+
+      has_child from: Node
+      has_child to: Node
+    end
+    Erange = Irange = Range
+
+    # Dynamic
+    def self.has_evaluated_segments
+      has_extra_children constituents: [Str, Begin, Ivar, Cvar, Gvar, Dstr, NthRef]
+    end
+    class DynamicLiteral < Node
+      def executed_loc_keys
+        if loc_hash[:heredoc_end]
+          [:expression, :heredoc_end]
+        else
+          [:begin, :end]
+        end
+      end
+    end
+    Dsym = Dstr = DynamicLiteral
+    DynamicLiteral.has_evaluated_segments
+
+    class Regexp < Node
+      include SimpleIfItsChildrenAre
+
+      has_evaluated_segments
+      has_child option: Regopt
+    end
+
+    class Xstr < Node
+      check_completion
+      has_evaluated_segments
+    end
+  end
+end

data/lib/deep_cover/node/loops.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module DeepCover
+  class Node
+    class For < Node
+      has_tracker :body
+      has_child assignments: [Mlhs, VariableAssignment], flow_entry_count: -> { body.flow_entry_count if body }
+      has_child iterable: [Node], flow_entry_count: -> { flow_entry_count }
+      has_child body: Node,
+                can_be_empty: -> { base_node.loc.end.begin },
+                flow_entry_count: :body_tracker_hits,
+                rewrite: '(%{body_tracker};%{local}=nil;%{node})'
+      check_completion
+
+      def execution_count
+        iterable.flow_completion_count
+      end
+    end
+
+    class Until < Node
+      has_tracker :body
+      has_child condition: Node, rewrite: '((%{node})) || (%{body_tracker};false)'
+      has_child body: Node,
+                can_be_empty: -> { base_node.loc.end.begin },
+                flow_entry_count: :body_tracker_hits
+      check_completion
+
+      def execution_count
+        # TODO: while this distringuishes correctly 0 vs >0, the number return is often too high
+        condition.flow_completion_count
+      end
+    end
+
+    class UntilPost < Node
+      has_tracker :body
+      has_child condition: Node, rewrite: '((%{node})) || (%{body_tracker};false)'
+      has_child body: Kwbegin, flow_entry_count: -> { body_tracker_hits + parent.flow_entry_count }
+      check_completion
+
+      def execution_count
+        # TODO: while this distringuishes correctly 0 vs >0, the number return is often too high
+        body.flow_completion_count
+      end
+      # TODO: test
+    end
+
+    class While < Node
+      has_tracker :body
+      has_child condition: Node, rewrite: '((%{node})) && %{body_tracker}'
+      has_child body: Node,
+                can_be_empty: -> { base_node.loc.end.begin },
+                flow_entry_count: :body_tracker_hits
+      check_completion
+
+      def execution_count
+        # TODO: while this distringuishes correctly 0 vs >0, the number return is often too high
+        condition.flow_completion_count
+      end
+    end
+
+    class WhilePost < Node
+      has_tracker :body
+      has_child condition: Node, rewrite: '((%{node})) && %{body_tracker}'
+      has_child body: Kwbegin, flow_entry_count: -> { body_tracker_hits + parent.flow_entry_count }
+      check_completion
+
+      def execution_count
+        # TODO: while this distringuishes correctly 0 vs >0, the number return is often too high
+        body.flow_completion_count
+      end
+      # TODO: test
+    end
+  end
+end

data/lib/deep_cover/node/mixin/can_augment_children.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module DeepCover
+  module Node::Mixin
+    module CanAugmentChildren
+      def self.included(base)
+        base.has_child_handler('remap_%{name}')
+        base.singleton_class.prepend ClassMethods
+      end
+
+      # Augment creates a covered node from the child_base_node.
+      # Caution: receiver is not fully constructed since it is also being augmented.
+      #          don't call `children`
+      def augment_children(child_base_nodes)
+        if child_base_nodes.size < (sz = self.class.min_children)
+          child_base_nodes = child_base_nodes.dup
+          child_base_nodes[sz..-1] = [] # Fill with nil
+        end
+        child_base_nodes.map.with_index do |child, child_index|
+          child_name = self.class.child_index_to_name(child_index, child_base_nodes.size)
+          if (klass = remap_child(child, child_name))
+            klass.new(child, parent: self, index: child_index)
+          else
+            child
+          end
+        end
+      end
+      private :augment_children
+
+      def remap_child(child, name = nil)
+        return unless child.is_a?(Parser::AST::Node)
+        class_name = Tools.camelize(child.type)
+        Node.const_defined?(class_name) ? Node.const_get(class_name) : Node
+      end
+
+      module ClassMethods
+        # This handles the following shortcuts:
+        #   has_child foo: {type: NodeClass, ...}
+        # same as:
+        #   has_child foo: [], remap: {type: NodeClass, ...}
+        # same as:
+        #   has_child foo: [NodeClass, ...], remap: {type: NodeClass, ...}
+        #
+        def has_child(remap: nil, **args)
+          name, types = args.first
+          if types.is_a? Hash
+            raise 'Use either remap or a hash as type but not both' if remap
+            remap = types
+            args[name] = types = []
+          end
+          if remap.is_a? Hash
+            type_map = remap
+            remap = ->(child) do
+              klass = type_map[child.type] if child.respond_to? :type
+              klass ||= type_map[child.class]
+              klass
+            end
+            types.concat(type_map.values).uniq!
+          end
+          super(**args, remap: remap)
+        end
+      end
+    end
+  end
+end

data/lib/deep_cover/node/mixin/check_completion.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative 'executed_after_children'
+
+module DeepCover
+  module Node::Mixin
+    module CheckCompletion
+      def check_completion(outer: '(%{node})', inner: '(%{node})')
+        has_tracker :completion
+        include ExecutedAfterChildren
+        alias_method :flow_completion_count, :completion_tracker_hits
+        pre, post = outer.split('%{node}')
+        # The local=local is to avoid Ruby warning about "Possible use of value in void context"
+        define_method(:rewrite) { "#{pre}(%{local}=#{inner};%{completion_tracker};%{local}=%{local})#{post}" }
+      end
+    end
+  end
+end

data/lib/deep_cover/node/mixin/child_can_be_empty.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module DeepCover
+  module Node::Mixin
+    module ChildCanBeEmpty
+      class << self
+        attr_accessor :last_empty_position # Ugly hack to pass info from Handler to constructor
+        def included(base)
+          base.has_child_handler('%{name}_can_be_empty')
+        end
+      end
+
+      def remap_child(child, name)
+        if child == nil
+          if (ChildCanBeEmpty.last_empty_position = child_can_be_empty(child, name))
+            return Node::EmptyBody
+          end
+        end
+        super
+      end
+
+      def child_can_be_empty(_child, _name = nil)
+        false
+      end
+    end
+  end
+end

data/lib/deep_cover/node/mixin/executed_after_children.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module DeepCover
+  module Node::Mixin
+    # By default, nodes are considered executed if they are entered.
+    # Some are considered executed only if their arguments complete.
+    module ExecutedAfterChildren
+      def execution_count
+        last = children_nodes_in_flow_order.last
+        return last.flow_completion_count if last
+        super
+      end
+    end
+  end
+end

data/lib/deep_cover/node/mixin/execution_location.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module DeepCover
+  module Node::Mixin
+    module ExecutionLocation
+      def self.included(base)
+        base.extend ClassMethods
+        base.has_child_handler('%{name}_executed_loc_keys')
+      end
+
+      module ClassMethods
+        # Macro to define the executed_loc_keys
+        def executed_loc_keys(*loc_keys)
+          # #flatten allows passing an empty array to be explicit
+          loc_keys = loc_keys.flatten
+          define_method :executed_loc_keys do
+            loc_keys
+          end
+        end
+      end
+
+      def executed_loc_keys
+        return [] unless executable?
+        loc_hash.keys - [:expression]
+      end
+
+      def child_executed_loc_keys(_child, _child_name)
+        nil
+      end
+
+      def executed_loc_hash
+        h = Tools.slice(loc_hash, *executed_loc_keys)
+        if (keys = parent.child_executed_loc_keys(self))
+          h.merge!(Tools.slice(parent.loc_hash, *keys))
+        end
+        h.reject { |k, v| v.nil? }
+      end
+
+      def executed_locs
+        executed_loc_hash.values
+      end
+
+      def loc_hash
+        base_node.respond_to?(:location) ? base_node.location.to_hash : {}
+      end
+
+      def expression
+        loc_hash[:expression]
+      end
+
+      def source
+        expression.source if expression
+      end
+
+      def diagnostic_expression
+        expression || parent.diagnostic_expression
+      end
+
+      # Returns an array of character numbers (in the original buffer) that
+      # pertain exclusively to this node (and thus not to any children).
+      def proper_range
+        executed_locs.map(&:to_a).inject([], :+).uniq
+      end
+    end
+  end
+end