deep-cover 0.5.2 → 0.5.3

data/lib/deep_cover/node/assignments.rb

@@ -2,6 +2,7 @@
 
 require_relative 'const'
 require_relative 'literals'
+require_relative 'keywords'
 
 module DeepCover
   class Node
@@ -18,7 +19,7 @@ module DeepCover
     Cvasgn = Gvasgn = Ivasgn = Lvasgn = VariableAssignment
 
     class Casgn < Node
-      has_child cbase: [Cbase, Const, nil, Self]
+      has_child cbase: [Cbase, Const, nil, Self, Begin, Kwbegin]
       has_child var_name: Symbol
       has_child value: [Node, nil]
 

data/lib/deep_cover/node/base.rb

@@ -52,18 +52,18 @@ module DeepCover
     end
 
     # Shortcut to access children
-    def [](v)
-      if v.is_a?(Integer)
-        children.fetch(v)
+    def [](lookup)
+      if lookup.is_a?(Integer)
+        children.fetch(lookup)
       else
-        found = find_all(v)
+        found = find_all(lookup)
         case found.size
         when 1
           found.first
         when 0
-          raise "No children of type #{v}"
+          raise "No children of type #{lookup}"
         else
-          raise "Ambiguous lookup #{v}, found #{found}."
+          raise "Ambiguous lookup #{lookup}, found #{found}."
         end
       end
     end

data/lib/deep_cover/node/block.rb

@@ -21,11 +21,6 @@ module DeepCover
       include WithBlock
     end
 
-    class CsendWithBlock < Csend
-      include WithBlock
-      refine_child actual_send: {safe_send: SendWithBlock}
-    end
-
     class SuperWithBlock < Node
       include WithBlock
       has_extra_children arguments: Node
@@ -34,9 +29,7 @@ module DeepCover
     class Block < Node
       check_completion
       has_tracker :body
-      has_child call: {send: SendWithBlock, csend: CsendWithBlock,
-                       zsuper: SuperWithBlock, super: SuperWithBlock,
-}
+      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 },
@@ -48,6 +41,15 @@ module DeepCover
       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

data/lib/deep_cover/node/case.rb

@@ -89,10 +89,10 @@ module DeepCover
         whens.map(&:body) << self.else
       end
 
-      def branches_summary(of = branches)
+      def branches_summary(of_branches = branches)
         texts = []
-        n = of.size
-        if of.include? self.else
+        n = of_branches.size
+        if of_branches.include? self.else
           texts << "#{'implicit ' unless has_else?}else"
           n -= 1
         end

data/lib/deep_cover/node/collections.rb

@@ -4,7 +4,14 @@ 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
@@ -16,6 +23,7 @@ module DeepCover
     end
 
     class Hash < Node
+      include SimpleIfEmpty
       has_extra_children elements: [Pair, Kwsplat]
       executed_loc_keys :begin, :end
     end

data/lib/deep_cover/node/if.rb

@@ -20,7 +20,7 @@ module DeepCover
 
       def child_can_be_empty(child, name)
         return false if name == :condition || style == :ternary
-        if (name == :true_branch) == (style == :if)
+        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
@@ -33,8 +33,8 @@ module DeepCover
         [true_branch, false_branch]
       end
 
-      def branches_summary(of = branches)
-        of.map do |jump|
+      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
@@ -49,6 +49,22 @@ module DeepCover
         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

data/lib/deep_cover/node/literals.rb

@@ -2,19 +2,30 @@
 
 require_relative 'begin'
 require_relative 'variables'
+require_relative 'collections'
 module DeepCover
   class Node
-    # Singletons
-    class SingletonLiteral < 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(Node) do
+      ::Class.new(StaticLiteral) do
         has_child value: type
-        executed_loc_keys :expression
       end
     end
     Sym = atom(::Symbol)
@@ -22,12 +33,11 @@ module DeepCover
     Float = atom(::Float)
     Complex = atom(::Complex)
     Rational = atom(::Rational)
-    class Regopt < Node
+    class Regopt < StaticLiteral
       has_extra_children options: [::Symbol]
-      executed_loc_keys :expression
     end
 
-    class Str < Node
+    class Str < StaticLiteral
       has_child value: ::String
 
       def executed_loc_keys
@@ -43,8 +53,17 @@ module DeepCover
       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
@@ -67,6 +86,8 @@ module DeepCover
     DynamicLiteral.has_evaluated_segments
 
     class Regexp < Node
+      include SimpleIfItsChildrenAre
+
       has_evaluated_segments
       has_child option: Regopt
     end

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

@@ -41,12 +41,12 @@ module DeepCover
         # same as:
         #   has_child foo: [NodeClass, ...], remap: {type: NodeClass, ...}
         #
-        def has_child(remap: nil, **h)
-          name, types = h.first
+        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
-            h[name] = types = []
+            args[name] = types = []
           end
           if remap.is_a? Hash
             type_map = remap
@@ -57,7 +57,7 @@ module DeepCover
             end
             types.concat(type_map.values).uniq!
           end
-          super(**h, remap: remap)
+          super(**args, remap: remap)
         end
       end
     end

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

@@ -10,7 +10,7 @@ module DeepCover
         end
       end
 
-      def remap_child(child, name = raise)
+      def remap_child(child, name)
         if child == nil
           if (ChildCanBeEmpty.last_empty_position = child_can_be_empty(child, name))
             return Node::EmptyBody

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

@@ -26,8 +26,12 @@ module DeepCover
         is_a?(Node::Send) && RAISING_MESSAGES.include?(message) && receiver == nil
       end
 
+      def is_warn?
+        is_a?(Node::Send) && message == :warn
+      end
+
       def is_default_argument?
-        parent.is_a?(Node::Optarg)
+        parent.is_a?(Node::Optarg) && simple_literal?
       end
 
       def is_case_implicit_else?
@@ -36,7 +40,7 @@ module DeepCover
 
       def is_trivial_if?
         # Supports only node being a branch or the fork itself
-        parent.is_a?(Node::If) && parent.condition.is_a?(Node::SingletonLiteral)
+        parent.is_a?(Node::If) && parent.condition.simple_literal?
       end
     end
   end

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

@@ -22,9 +22,9 @@ module DeepCover
       end
 
       module ClassMethods
-        def has_child(rest_: false, refine_: false, **h)
-          raise "Needs exactly one custom named argument, got #{h.size}" if h.size != 1
-          name, types = h.first
+        def has_child(rest_: false, refine_: false, **args)
+          raise "Needs exactly one custom named argument, got #{args.size}" if args.size != 1
+          name, types = args.first
           raise TypeError, "Expect a Symbol for name, got a #{name.class} (#{name.inspect})" unless name.is_a?(Symbol)
           update_children_const(name, rest: rest_) unless refine_
           define_accessor(name) unless refine_
@@ -32,15 +32,15 @@ module DeepCover
           self
         end
 
-        def has_extra_children(**h)
-          has_child(**h, rest_: true)
+        def has_extra_children(**args)
+          has_child(**args, rest_: true)
         end
 
-        def refine_child(child_name = nil, **h)
+        def refine_child(child_name = nil, **args)
           if child_name
-            h = {child_name => self::CHILDREN_TYPES.fetch(child_name), **h}
+            args = {child_name => self::CHILDREN_TYPES.fetch(child_name), **args}
           end
-          has_child(**h, refine_: true)
+          has_child(**args, refine_: true)
         end
 
         def child_index_to_name(index, nb_children)

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

@@ -30,11 +30,11 @@ module DeepCover
           class_eval <<-EVAL, __FILE__, __LINE__ + 1
             module #{const_name}                                     # module RewriteHandler
               module ClassMethods                                    #   module ClassMethods
-                def has_child(#{action}: nil, **h)                   #     def has_child(rewrite: nil, **h)
-                  name, _types = h.first                             #       name, _types = h.first
+                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(**h)                                         #       super(**h)
+                  super(**args)                                      #       super(**args)
                 end                                                  #     end
               end                                                    #   end
 

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

@@ -9,10 +9,14 @@ module DeepCover
       TRACKERS = {}
 
       def initialize(*)
-        @tracker_offset = covered_code.allocate_trackers(self.class::TRACKERS.size).begin
+        @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")]
@@ -29,10 +33,10 @@ module DeepCover
           i = self::TRACKERS[name] = self::TRACKERS.size
           class_eval <<-EVAL, __FILE__, __LINE__ + 1
             def #{name}_tracker_source
-              covered_code.tracker_source(@tracker_offset + #{i})
+              tracker_storage.tracker_source(@tracker_offset + #{i})
             end
             def #{name}_tracker_hits
-              covered_code.tracker_hits(@tracker_offset + #{i})
+              tracker_storage[@tracker_offset + #{i}]
             end
           EVAL
         end

data/lib/deep_cover/node/root.rb

@@ -7,7 +7,7 @@ module DeepCover
               can_be_empty: -> { Parser::Source::Range.new(covered_code.buffer, 0, 0) },
               is_statement: true,
               rewrite: -> {
-                "#{covered_code.trackers_setup_source};%{root_tracker};%{local}=nil;%{node}"
+                "#{tracker_storage.setup_source};%{root_tracker};%{local}=nil;%{node}"
               }
     attr_reader :covered_code
     alias_method :flow_entry_count, :root_tracker_hits

data/lib/deep_cover/node/send.rb

@@ -67,16 +67,54 @@ module DeepCover
       check_completion
     end
 
+    class CsendInnerSend < SendBase
+      has_tracker :completion
+      include ExecutedAfterChildren
+
+      def has_block?
+        parent.parent.is_a?(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 :conditional
+      has_tracker :not_nil
       has_child receiver: Node,
-                rewrite: '(%{local}=%{node};%{conditional_tracker} if %{local} != nil;%{local})'
+                rewrite: '(%{local}=%{node};if nil != %{local};%{not_nil_tracker};%{local}=%{local}'
+      REWRITE_SUFFIX = '%{node};%{local};else;nil;end)'
 
-      has_child actual_send: {safe_send: Send},
-                flow_entry_count: :conditional_tracker_hits
+      has_child actual_send: {safe_send: CsendInnerSend},
+                flow_entry_count: :not_nil_tracker_hits
 
-      def initialize(base_node, base_children: base_node.children, **)
+      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
@@ -84,6 +122,14 @@ module DeepCover
 
       executed_loc_keys :dot
 
+      def has_block?
+        parent.is_a?(Block)
+      end
+
+      def rewrite
+        REWRITE_SUFFIX unless has_block?
+      end
+
       def execution_count
         receiver.flow_completion_count
       end
@@ -98,8 +144,8 @@ module DeepCover
         ]
       end
 
-      def branches_summary(of = branches)
-        of.map do |jump|
+      def branches_summary(of_branches = branches)
+        of_branches.map do |jump|
           jump == actual_send ? 'safe send' : 'nil shortcut'
         end.join(' and ')
       end