deep-cover 0.6.2 → 0.6.3.pre

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

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-module DeepCover
-  module Node::Mixin
-    module HasChildHandler
-      def self.included(base)
-        base.extend ClassMethods
-      end
-
-      def call_child_handler(template, child, child_name = nil)
-        child_name ||= self.child_index_to_name(child.index)
-        method_name = format(template, name: child_name)
-        if respond_to?(method_name)
-          args = [child, child_name]
-          arity = method(method_name).arity
-          if arity >= 0
-            args = args[0...arity]
-          end
-          answer = send(method_name, *args)
-        end
-        answer
-      end
-      private :call_child_handler
-
-      module ClassMethods
-        def has_child_handler(template)
-          child_method_name = format(template, name: 'child')
-          action = template.gsub(/_%{name}/, '').gsub(/%{name}_/, '')
-          const_name = "#{Tools.camelize(action)}Handler"
-          class_eval <<-EVAL, __FILE__, __LINE__ + 1
-            module #{const_name}                                     # module RewriteHandler
-              module ClassMethods                                    #   module ClassMethods
-                def has_child(#{action}: nil, **args)                #     def has_child(rewrite: nil, **args)
-                  name, _types = args.first                          #       name, _types = args.first
-                  define_child_handler(#{template.inspect},          #       define_child_handler('rewrite_%{child}',
-                    name, #{action})                                 #         name, rewrite)
-                  super(**args)                                      #       super(**args)
-                end                                                  #     end
-              end                                                    #   end
-
-              def #{child_method_name}(child, name = nil)            #   def rewrite_child(child, name = nil)
-                call_child_handler(#{template.inspect}, child,       #     call_child_handler('rewrite_%{child}', child,
-                  name) || super                                     #       name) || super
-              end                                                    #   end
-            end                                                      # end
-            include #{const_name}                                    # include RewriteHandler
-            singleton_class.prepend #{const_name}::ClassMethods      # singleton_class.prepend RewriteHandler::ClassMethods
-          EVAL
-        end
-
-        def define_child_handler(template, name, action)
-          method_name = format(template, name: name)
-          case action
-          when nil
-            # Nothing to do
-          when Symbol
-            define_method(method_name) do |*args|
-              arity = method(action).arity
-              if arity < 0
-                send(action, *args)
-              else
-                send(action, *args[0...arity])
-              end
-            end
-          when Proc
-            define_method(method_name, &action)
-          else
-            define_method(method_name) { |*| action }
-          end
-        end
-        private :define_child_handler
-      end
-    end
-  end
-end

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

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-module DeepCover
-  module Node::Mixin
-    module HasTracker
-      def self.included(base)
-        base.extend ClassMethods
-      end
-      TRACKERS = {}
-
-      def initialize(*)
-        @tracker_offset = tracker_storage.allocate_trackers(self.class::TRACKERS.size).begin
-        super
-      end
-
-      def tracker_storage
-        covered_code.tracker_storage
-      end
-
-      def tracker_sources
-        self.class::TRACKERS.map do |name, _|
-          [:"#{name}_tracker", send(:"#{name}_tracker_source")]
-        end.to_h
-      end
-
-      module ClassMethods
-        def inherited(base)
-          base.const_set :TRACKERS, self::TRACKERS.dup
-          super
-        end
-
-        def has_tracker(name)
-          i = self::TRACKERS[name] = self::TRACKERS.size
-          class_eval <<-EVAL, __FILE__, __LINE__ + 1
-            def #{name}_tracker_source
-              tracker_storage.tracker_source(@tracker_offset + #{i})
-            end
-            def #{name}_tracker_hits
-              tracker_storage[@tracker_offset + #{i}]
-            end
-          EVAL
-        end
-      end
-    end
-  end
-end

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

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module DeepCover
-  module Node::Mixin
-    module IsStatement
-      def self.included(base)
-        base.has_child_handler('is_%{name}_statement')
-      end
-
-      def is_statement
-        parent.is_child_statement(self)
-      end
-
-      # Default child rewriting rule
-      def is_child_statement(child, name = nil)
-        :if_incompatible
-      end
-    end
-  end
-end

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

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module DeepCover
-  module Node::Mixin
-    module Rewriting
-      def self.included(base)
-        base.has_child_handler('rewrite_%{name}')
-      end
-
-      # Code to add before and after the node for covering purposes
-      def rewrite
-      end
-
-      # Default child rewriting rule
-      def rewrite_child(child, name = nil)
-      end
-
-      # Replaces all the '%{local}' or '%{some_tracker}' in rewriting rules
-      def resolve_rewrite(rule, context)
-        return if rule == nil
-        sources = context.tracker_sources
-        format(rule, local: covered_code.local_var, node: '%{node}', **sources)
-      end
-
-      # Returns an array of [range, rule], where rule is a string containing '%{node}'
-      # Rules must be ordered inner-most first
-      def rewriting_rules
-        [
-          resolve_rewrite(rewrite, self),
-          resolve_rewrite(parent.rewrite_child(self), parent),
-        ].compact.map { |rule| [expression, rule] }
-      end
-    end
-  end
-end

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

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module DeepCover
-  module Node::Mixin
-    module Wrapper
-      def initialize(base_node, **kwargs)
-        super(base_node, base_children: [base_node], **kwargs)
-      end
-
-      def executed_loc_keys
-        []
-      end
-    end
-  end
-end

data/lib/deep_cover/node/module.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'const'
-
-module DeepCover
-  class Node
-    class ModuleName < Node
-      has_child scope: [Node, nil]
-      has_child const_name: Symbol
-
-      def flow_completion_count
-        parent.execution_count
-      end
-
-      def execution_count
-        if scope
-          scope.flow_completion_count
-        else
-          super
-        end
-      end
-    end
-
-    class Module < Node
-      check_completion
-      has_tracker :body_entry
-      has_child const: {const: ModuleName}
-      has_child body: Node,
-                can_be_empty: -> { base_node.loc.end.begin },
-                rewrite: '%{body_entry_tracker};%{local}=nil;%{node}',
-                is_statement: true,
-                flow_entry_count: :body_entry_tracker_hits
-      executed_loc_keys :keyword
-
-      def execution_count
-        body_entry_tracker_hits
-      end
-    end
-
-    class Class < Node
-      check_completion
-      has_tracker :body_entry
-      has_child const: {const: ModuleName}
-      has_child inherit: [Node, nil] # TODO
-      has_child body: Node,
-                can_be_empty: -> { base_node.loc.end.begin },
-                rewrite: '%{body_entry_tracker};%{node}',
-                is_statement: true,
-                flow_entry_count: :body_entry_tracker_hits
-      executed_loc_keys :keyword
-
-      def execution_count
-        body_entry_tracker_hits
-      end
-    end
-
-    # class << foo
-    class Sclass < Node
-      has_child object: Node
-      has_child body: Node,
-                can_be_empty: -> { base_node.loc.end.begin },
-                is_statement: true
-      # TODO
-    end
-  end
-end

data/lib/deep_cover/node/root.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module DeepCover
-  class Node::Root < Node
-    has_tracker :root
-    has_child main: Node,
-              can_be_empty: -> { Parser::Source::Range.new(covered_code.buffer, 0, 0) },
-              is_statement: true,
-              rewrite: -> {
-                "#{tracker_storage.setup_source};%{root_tracker};%{local}=nil;%{node}"
-              }
-    attr_reader :covered_code
-    alias_method :flow_entry_count, :root_tracker_hits
-
-    def initialize(child_ast, covered_code)
-      @covered_code = covered_code
-      super(nil, parent: nil, base_children: [child_ast])
-    end
-  end
-end

data/lib/deep_cover/node/send.rb

@@ -1,161 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'literals'
-require_relative 'branch'
-
-module DeepCover
-  class Node
-    class SendBase < Node
-      has_child receiver: [Node, nil]
-      has_child message: Symbol
-      has_extra_children arguments: Node
-      executed_loc_keys :dot, :selector_begin, :selector_end, :operator
-
-      def loc_hash
-        hash = super.dup
-        selector = hash.delete(:selector)
-
-        # Special case for foo[bar]=baz, but not for foo.[]= bar, baz: we split selector into begin and end
-        if base_node.location.dot == nil && [:[], :[]=].include?(message)
-          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.delete(:dot) if type == :safe_send # Hack. API to get a Parser::AST::Send::Map without the dot is crappy.
-          hash[:selector_begin] = selector
-        end
-
-        hash
-      end
-
-      # Rules must be ordered inner-most first
-      def rewriting_rules
-        rules = super
-        if need_parentheses?
-          range = arguments.last.expression.with(begin_pos: loc_hash[:selector_begin].end_pos)
-          rules.unshift [range, '(%{node})']
-        end
-        rules
-      end
-
-      private
-
-      # In different circumstances, we need ().
-      # Deal with ambiguous cases where a method is hidden by a local. Ex:
-      #   foo 42, 'hello'  #=> Works
-      #   foo (42), 'hello'  #=> Simplification of what DeepCover would generate, still works
-      #   foo = 1; foo 42, 'hello'  #=> works
-      #   foo = 1; foo (42), 'hello'  #=> syntax error.
-      #   foo = 1; foo((42), 'hello')  #=> works
-      # Deal with do/end block. Ex:
-      #   x.foo 42, 43 # => ok
-      #   x.foo (42), 43 # => ok
-      #   x.foo ((42)), 43 # => ok
-      #   x.foo 42, 43 do ; end # => ok
-      #   x.foo (42), 43 do ; end # => ok
-      #   x.foo ((42)), 43 do ; end # => parse error!
-      def need_parentheses?
-        true unless
-          arguments.empty? || # No issue when no arguments
-          loc_hash[:selector_end] || # No issue with foo[bar]= and such
-          loc_hash[:operator] || # No issue with foo.bar=
-          (receiver && !loc_hash[:dot]) || # No issue with foo + bar
-          loc_hash[:begin] # Ok if has parentheses
-      end
-    end
-
-    class Send < SendBase
-      check_completion
-    end
-
-    class CsendInnerSend < SendBase
-      has_tracker :completion
-      include ExecutedAfterChildren
-
-      def has_block?
-        parent.has_block?
-      end
-
-      def rewrite
-        # All the rest of the rewriting logic is in Csend
-        '%{node};%{completion_tracker};' unless has_block?
-      end
-
-      def flow_completion_count
-        return parent.parent.flow_completion_count if has_block?
-        completion_tracker_hits
-      end
-
-      def loc_hash
-        # This is only a partial Send, the receiver param and the dot are actually handled by the parent Csend.
-        h = super.dup
-        h[:expression] = h[:expression].with(begin_pos: h[:selector_begin].begin_pos)
-        h
-      end
-    end
-
-    class Csend < Node
-      # The overall rewriting goal is this:
-      #    temp = *receiver*;
-      #    if nil != temp
-      #      TRACK_my_NOT_NIL
-      #      temp = temp&.*actual_send*{block}
-      #      TRACK_actual_send_COMPLETION
-      #      t
-      #    else
-      #      nil
-      #    end
-      # This is split across the children and the CsendInnerSend
-      include Branch
-      has_tracker :not_nil
-      has_child receiver: Node,
-                rewrite: '(%{local}=%{node};if nil != %{local};%{not_nil_tracker};%{local}=%{local}'
-      REWRITE_SUFFIX = '%{node};%{local};else;nil;end)'
-
-      has_child actual_send: {safe_send: CsendInnerSend},
-                flow_entry_count: :not_nil_tracker_hits
-
-      def initialize(base_node, base_children: base_node.children, **) # rubocop:disable Naming/UncommunicativeMethodParamName [#5436]
-        send_without_receiver = base_node.updated(:safe_send, [nil, *base_node.children.drop(1)])
-        base_children = [base_children.first, send_without_receiver]
-        super
-      end
-
-      executed_loc_keys :dot
-
-      def has_block?
-        parent.is_a?(Block) && parent.child_index_to_name(index) == :call
-      end
-
-      def rewrite
-        REWRITE_SUFFIX unless has_block?
-      end
-
-      def execution_count
-        receiver.flow_completion_count
-      end
-
-      def message
-        actual_send.message
-      end
-
-      def branches
-        [TrivialBranch.new(condition: receiver, other_branch: actual_send),
-         actual_send,
-        ]
-      end
-
-      def branches_summary(of_branches = branches)
-        of_branches.map do |jump|
-          jump == actual_send ? 'safe send' : 'nil shortcut'
-        end.join(' and ')
-      end
-    end
-
-    class MatchWithLvasgn < Node
-      check_completion
-      has_child receiver: Regexp
-      has_child compare_to: Node
-      # TODO: test
-    end
-  end
-end