semdiff 0.1.0

data/lib/semdiff/constants_compiler.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Semdiff
+  # ConstantsCompiler is a compiler that folds constant literal
+  # expressions into single constants.
+  #
+  # @example
+  #   ```ruby
+  #   # Expression        Canonical Form
+  #   (2 + 3)             5
+  #   (4 * 2 - 1)         7
+  #   (8 / 4) + 3         5
+  #   (1 + 2**3)          9
+  #   ```
+  class ConstantsCompiler < ::Prism::MutationCompiler
+    include Prism::DSL
+    include CompilerUtils
+
+    SUPPORTED_OPS = %i[+ - * / % ** & | ^ << >>].freeze
+
+    def visit_call_node(node)
+      receiver  = visit(node.receiver)
+      arguments = visit(node.arguments)
+      result    = nil
+
+      result = fold_constants(node, receiver, arguments) if constant_foldable?(node, receiver, arguments)
+
+      if result
+        CompilerUtils.inherit_newline(node, result)
+      else
+        # finalized transformations
+        node.copy(receiver: receiver, arguments: arguments, block: visit(node.block))
+      end
+    end
+
+    def visit_parentheses_node(node)
+      if node.multiple_statements?
+        statements = visit_all(node.body.body)
+        body = node.body.copy(body: statements)
+        return node.copy(body: body)
+      end
+
+      single_child = node.body.body.first
+      visited = visit(single_child)
+
+      return visited if visited.is_a?(Prism::IntegerNode)
+
+      new_body = node.body.copy(body: [visited])
+      node.copy(body: new_body)
+    end
+
+    private
+
+    def constant_foldable?(node, receiver, arguments)
+      receiver.is_a?(Prism::IntegerNode) &&
+        arguments&.arguments&.size == 1 &&
+        arguments.arguments.first.is_a?(Prism::IntegerNode) &&
+        SUPPORTED_OPS.include?(node.name)
+    end
+
+    def fold_constants(node, receiver, arguments)
+      lhs = receiver.value
+      rhs = arguments.arguments.first.value
+      op  = node.name
+
+      case op
+      when :/, :%
+        return nil if rhs.zero?
+      when :**
+        return nil if rhs.negative?
+      end
+
+      result = begin
+        lhs.send(op, rhs)
+      rescue StandardError
+        nil
+      end
+
+      return nil unless result.is_a?(Integer)
+
+      flags = integer_base_flag(:decimal) | Prism::NodeFlags::STATIC_LITERAL
+      integer_node(
+        node_id: node.node_id,
+        source: node.send(:source),
+        location: node.location,
+        flags: flags,
+        value: result
+      )
+    end
+  end
+end

data/lib/semdiff/identity_compiler.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module Semdiff
+  # IdentityCompiler is a compiler that simplifies arithmetic identities
+  # for variables based on type information.
+  #
+  # @example
+  #   ```ruby
+  #   # Expression        Canonical Form
+  #   x + 0               x       # zero addition
+  #   x - 0               x       # zero subtraction
+  #   0 - x               -x      # unary negation
+  #   x * 1               x       # multiplicative identity
+  #   0 * x               0       # zero multiplication
+  #   x / 1               x       # division identity
+  #   x ** 1              x       # exponent identity
+  #   x ** 0              1       # zero exponent
+  #   +x                  x       # unary plus is noop
+  #   -(-x)               x       # double negation
+  #   ---x                -x      # multiple negation
+  #   ```
+  class IdentityCompiler < ::Prism::MutationCompiler
+    include Prism::DSL
+    include CompilerUtils
+
+    def initialize(node_types)
+      @node_types = node_types
+      super()
+    end
+
+    def visit_call_node(node)
+      lhs         = visit(node.receiver)
+      arguments   = visit(node.arguments)
+      rhs         = arguments&.arguments&.first
+      lhs_types   = lhs && @node_types[lhs.node_id]
+      rhs_types   = rhs && @node_types[rhs.node_id]
+      lhs_numeric = lhs_types&.anybits?(NodeTypeFlags::NUMERIC)
+      rhs_numeric = rhs_types&.anybits?(NodeTypeFlags::NUMERIC)
+      lhs_integer = lhs_numeric && lhs_types.anybits?(NodeTypeFlags::INTEGER)
+      rhs_integer = rhs_numeric && rhs_types.anybits?(NodeTypeFlags::INTEGER)
+      result      = nil
+
+      case node.name
+      when :+
+        if lhs_numeric && zero_literal?(rhs)
+          # x + 0 => x
+          result = lhs
+        elsif rhs_numeric && zero_literal?(lhs)
+          # 0 + x => x
+          result = rhs
+        end
+      when :+@
+        # + x => x
+        result = lhs if lhs_numeric
+      when :-
+        if lhs_numeric && zero_literal?(rhs)
+          # x - 0 => x
+          result = lhs
+        elsif rhs_numeric && zero_literal?(lhs)
+          # 0 - x => -x
+          result = node.copy(
+            receiver: rhs,
+            name: :-@,
+            arguments: nil
+          )
+        end
+      when :-@
+        inner_lhs = lhs
+        neg_count = 1
+        loop do
+          if inner_lhs.type == :parentheses_node && !inner_lhs.multiple_statements?
+            # -( - x ) => x
+            inner_lhs = inner_lhs.body.body.first
+            next
+          end
+          if inner_lhs.type == :call_node && inner_lhs.name == :-@
+            # ---x => -x
+            inner_lhs = inner_lhs.receiver
+            neg_count += 1
+            next
+          end
+          break
+        end
+        result = inner_lhs if neg_count.even?
+      when :*
+        if lhs_numeric && one_literal?(rhs)
+          # x * 1 => x
+          result = lhs
+        elsif rhs_numeric && one_literal?(lhs)
+          # 1 * x => x
+          result = rhs
+        elsif (lhs_integer && zero_literal?(rhs)) ||
+              (rhs_integer && zero_literal?(lhs))
+          # 0 * x or x * 0 => 0
+          # This works for integers, but not for Float
+          # because of INFINITY or NaN instead of 0.
+          result = rhs && zero_literal?(rhs) ? rhs : lhs
+        end
+      when :/
+        # x / 1 => x
+        result = lhs if lhs_numeric && one_literal?(rhs)
+      when :**
+        if lhs_numeric && one_literal?(rhs)
+          # x ** 1 => x
+          result = lhs
+        elsif lhs_integer && zero_literal?(rhs)
+          # x ** 0 => 1
+          flags = integer_base_flag(:decimal) | Prism::NodeFlags::STATIC_LITERAL
+          result = integer_node(
+            source: node.send(:source),
+            location: node.location,
+            flags: flags,
+            value: 1
+          )
+        end
+      end
+
+      if result
+        CompilerUtils.inherit_newline(node, result)
+      else
+        # finalized transformations
+        node.copy(receiver: lhs, arguments: arguments, block: visit(node.block))
+      end
+    end
+
+    private
+
+    def zero_literal?(node)
+      node.type == :integer_node && node.value.zero?
+    end
+
+    def one_literal?(node)
+      node.type == :integer_node && node.value == 1
+    end
+  end
+end

data/lib/semdiff/structures_compiler.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+module Semdiff
+  # StructuresCompiler is a compiler that normalizes common
+  # data structure operations.
+  #
+  # @example
+  #   ```ruby
+  #   # Expression              Canonical Form
+  #   Array.new                 []
+  #   Array.new(0)              []
+  #   Hash.new                  {}
+  #   Hash[]                    {}
+  #   array.push(e)             array << e
+  #   "a".concat("b")           "a" << "b"
+  #   hash.store(key, value)    hash[key] = value
+  #   ''                        ""
+  #   ```
+  class StructuresCompiler < ::Prism::MutationCompiler
+    include Prism::DSL
+    include CompilerUtils
+
+    def visit_call_node(node)
+      receiver  = visit(node.receiver)
+      arguments = visit(node.arguments)
+      block     = visit(node.block)
+
+      result = case node.name
+               when :new
+                 transform_constructor(node, receiver, arguments, block)
+               when :[]
+                 transform_class_bracket_method(node, receiver, arguments)
+               when :push
+                 transform_push_to_shovel(node, receiver, arguments)
+               when :concat
+                 transform_concat_to_shovel(node, receiver, arguments)
+               when :store
+                 transform_store_to_bracket_assign(node, receiver, arguments)
+               end
+
+      if result
+        CompilerUtils.inherit_newline(node, result)
+      else
+        node.copy(receiver: receiver, arguments: arguments, block: block)
+      end
+    end
+
+    private
+
+    def transform_constructor(node, receiver, arguments, block)
+      return nil unless receiver.is_a?(Prism::ConstantReadNode)
+      return nil if block
+
+      case receiver.name
+      when :Array
+        transform_array_new(node, arguments)
+      when :Hash
+        transform_hash_new(node, arguments)
+      end
+    end
+
+    def transform_array_new(node, arguments)
+      # Array.new -> []
+      if arguments.nil? || arguments.arguments.empty?
+        return array_node(
+          node_id: node.node_id,
+          source: node.send(:source),
+          location: node.location,
+          flags: Prism::NodeFlags::STATIC_LITERAL,
+          elements: [],
+          opening_loc: node.receiver.location,
+          closing_loc: node.message_loc
+        )
+      end
+
+      # Array.new(0) -> []
+      if arguments.arguments.size == 1 &&
+         arguments.arguments.first.is_a?(Prism::IntegerNode) &&
+         arguments.arguments.first.value.zero?
+        return array_node(
+          node_id: node.node_id,
+          source: node.send(:source),
+          location: node.location,
+          flags: Prism::NodeFlags::STATIC_LITERAL,
+          elements: [],
+          opening_loc: node.receiver.location,
+          closing_loc: node.closing_loc
+        )
+      end
+
+      nil
+    end
+
+    def transform_hash_new(node, arguments)
+      # Hash.new -> {} (only without arguments)
+      if arguments.nil? || arguments.arguments.empty?
+        return hash_node(
+          node_id: node.node_id,
+          source: node.send(:source),
+          location: node.location,
+          flags: Prism::NodeFlags::STATIC_LITERAL,
+          elements: [],
+          opening_loc: node.receiver.location,
+          closing_loc: node.message_loc
+        )
+      end
+
+      nil
+    end
+
+    def transform_class_bracket_method(node, receiver, arguments)
+      return nil unless receiver.is_a?(Prism::ConstantReadNode)
+
+      # Hash[] -> {}
+      if receiver.name == :Hash && (arguments.nil? || arguments.arguments.empty?)
+        return hash_node(
+          node_id: node.node_id,
+          source: node.send(:source),
+          location: node.location,
+          flags: Prism::NodeFlags::STATIC_LITERAL,
+          elements: [],
+          opening_loc: node.opening_loc,
+          closing_loc: node.closing_loc
+        )
+      end
+
+      nil
+    end
+
+    def transform_push_to_shovel(node, receiver, arguments)
+      # array.push(e) -> array << e
+      return nil unless arguments&.arguments&.size == 1
+
+      call_node(
+        node_id: node.node_id,
+        source: node.send(:source),
+        location: node.location,
+        flags: 0,
+        receiver: receiver,
+        call_operator_loc: nil,
+        name: :<<,
+        message_loc: node.message_loc,
+        opening_loc: nil,
+        arguments: arguments,
+        closing_loc: nil,
+        block: nil
+      )
+    end
+
+    def transform_concat_to_shovel(node, receiver, arguments)
+      # "a".concat("b") -> "a" << "b"
+      return nil unless arguments&.arguments&.size == 1
+      return nil unless receiver.is_a?(Prism::StringNode)
+
+      call_node(
+        node_id: node.node_id,
+        source: node.send(:source),
+        location: node.location,
+        flags: 0,
+        receiver: receiver,
+        call_operator_loc: nil,
+        name: :<<,
+        message_loc: node.message_loc,
+        opening_loc: nil,
+        arguments: arguments,
+        closing_loc: nil,
+        block: nil
+      )
+    end
+
+    def transform_store_to_bracket_assign(node, receiver, arguments)
+      # hash.store(key, value) -> hash[key] = value
+      return nil unless arguments&.arguments&.size == 2
+
+      # NOTE: there seems to be a bug here where flags for the
+      # hash[key] = value callnode has 256 (1 << 8) set, we
+      # copy it here to pass === check
+      call_node(
+        node_id: node.node_id,
+        source: node.send(:source),
+        location: node.location,
+        flags: call_node_flag(:attribute_write) | (1 << 8),
+        receiver: receiver,
+        call_operator_loc: nil,
+        name: :[]=,
+        message_loc: node.message_loc,
+        opening_loc: node.opening_loc,
+        arguments: arguments,
+        closing_loc: node.closing_loc,
+        block: nil
+      )
+    end
+  end
+end

data/lib/semdiff/type_visitor.rb

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+
+# require 'prism'
+
+module Semdiff
+  # This visitor is responsible for mapping AST nodes to type information.
+  # Returns a Hash of `node_id => flags` : `{10 => 7, 11 => 7}`
+  class TypeVisitor < ::Prism::Visitor
+    include ::Typeguard::TypeModel::Definitions
+
+    UNSAFE_NUMERIC_CLASSES = %i[Date::Infinity].freeze
+    NUMERIC_CLASSES = %i[Numeric Integer Float Rational Complex].freeze
+    ENUMERABLE_CLASSES = %i[
+      Enumerable ARGF Array Dir Enumerator ENV Hash
+      IO Range Struct CSV CSV::Table CSV::Row Set
+    ].freeze
+
+    def initialize(types)
+      @types = types
+      @mods = map_mods(@types)
+      @scope = []
+      @mod = nil
+      @method = nil
+      @node_types = {}
+      super()
+    end
+
+    def visit_program_node(node)
+      super
+      @node_types
+    end
+
+    def visit_module_node(node)
+      process_mod_node(node)
+    end
+
+    def visit_class_node(node)
+      process_mod_node(node)
+    end
+
+    def visit_def_node(node)
+      # Either look in the current mod or root
+      haystack = @mod&.children || (@types if @scope.empty?)
+      # NOTE: If an explicit receiver is provided, we look
+      # for singleton methods on the current mod,
+      # assuming that the receiver is self. Could be
+      # expanded by resolving the receiver if not self.
+      scope = node.receiver ? :class : :instance
+      needle = node.name
+      method = haystack.find do |e|
+        e.is_a?(MethodDefinition) && e.name == needle && e.scope == scope
+      end
+      @method = method
+      super
+      @method = nil
+    end
+
+    def visit_class_variable_read_node(node)
+      types = find_var_types(:class, node.name)
+      store_node_types(node, types)
+      super
+    end
+
+    def visit_constant_read_node(node)
+      types = find_var_types(:constant, node.name)
+      store_node_types(node, types)
+      super
+    end
+
+    def visit_instance_variable_read_node(node)
+      types = find_var_types(:instance, node.name)
+      store_node_types(node, types)
+      super
+    end
+
+    def visit_local_variable_read_node(node)
+      unless @method.nil? || @method.parameters.empty?
+        params = @method.parameters.find { |p| p.name == node.name }
+        types = params&.types
+        store_node_types(node, types)
+      end
+      super
+    end
+
+    def visit_call_node(node)
+      if node.variable_call? || node.receiver&.type == :self_node
+        # In the case where a singleton method is defined on the
+        # current mod: `class << self; attr_reader :a; end` we
+        # might have type information (a var) on the mod.
+        types = find_var_types(:self, node.name)
+        store_node_types(node, types)
+      end
+      super
+    end
+
+    private
+
+    def map_mods(types)
+      mods = {}
+      return mods if types.nil?
+
+      queue = Array(types).select { |o| o.respond_to?(:vars) }
+      visited = Set.new
+      while (mod = queue.shift)
+        next unless mod && visited.add?(mod.object_id)
+
+        mods[mod.name] = mod
+        queue.concat(mod.children.select { |c| c.respond_to?(:vars) })
+      end
+      mods
+    end
+
+    def compute_fqn(path_node, scope)
+      fqn = scope.join('::')
+
+      case path_node.type
+      when :constant_read_node
+        name_s = path_node.name.to_s
+        fqn.empty? ? name_s : "#{fqn}::#{name_s}"
+      when :constant_path_node
+        path = path_node.full_name
+        return path[2..] if path.start_with?('::')
+
+        candidate = fqn.empty? ? path : "#{fqn}::#{path}"
+        if @mods.include?(candidate) || !@mods.include?(path)
+          candidate
+        else
+          path
+        end
+      else
+        raise "Unsupported path node type for #{path_node.type}"
+      end
+    end
+
+    def process_mod_node(node)
+      fqn = compute_fqn(node.constant_path, @scope)
+      prev_scope = @scope
+      @scope = fqn.split('::')
+      prev_mod = @mod
+      @mod = @mods[fqn]
+      visit_child_nodes(node)
+      @scope = prev_scope
+      @mod = prev_mod
+    end
+
+    def find_var_types(scope, name)
+      return nil if @mod.nil? || @mod.vars.empty?
+
+      var = @mod.vars.find { |v| v.scope == scope && v.name == name }
+      var&.types
+    end
+
+    def store_node_types(node, types)
+      return if types.nil?
+
+      flags = 0
+      if types.one?
+        flags |= NodeTypeFlags::ONE
+        t = types.first
+        if t.shape == :basic
+          flags |= NodeTypeFlags::BASIC
+          case t.kind
+          when :Integer
+            flags |= NodeTypeFlags::INTEGER
+          when :Float
+            flags |= NodeTypeFlags::FLOAT
+          when :boolean
+            flags |= NodeTypeFlags::BOOLEAN
+          when :String
+            flags |= NodeTypeFlags::STRING
+          end
+        end
+      end
+      is_numeric = types.all? { |e| NUMERIC_CLASSES.include?(e.kind) }
+      flags |= NodeTypeFlags::NUMERIC if is_numeric
+      is_enumerable = types.all? { |e| ENUMERABLE_CLASSES.include?(e.kind) }
+      flags |= NodeTypeFlags::ENUMERABLE if is_enumerable
+      @node_types[node.node_id] = flags
+    end
+  end
+
+  module NodeTypeFlags
+    # a node with a single type [a] instead of a union [a, b]
+    ONE = 1 << 0
+
+    # a node with a basic shape, single constant, no children
+    BASIC = 1 << 1
+
+    # an Integer node
+    INTEGER = 1 << 2
+
+    # a Float node
+    FLOAT = 1 << 3
+
+    # a Booolean node
+    BOOLEAN = 1 << 4
+
+    # a String node
+    STRING = 1 << 5
+
+    # a Numeric subclass node
+    NUMERIC = 1 << 6
+
+    # a node that includes (or extends) Enumerable
+    ENUMERABLE = 1 << 7
+  end
+end

data/lib/semdiff/utils/compiler_utils.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Semdiff
+  module CompilerUtils
+    # NOTE: Uses `send` to access protected flags, seems
+    # preferable over extending Node(s)
+    def self.inherit_newline(parent, node)
+      need_newline = parent.newline?
+      if need_newline == node.newline?
+        node
+      else
+        flags = node.send(:flags)
+        new_flags = if need_newline
+                      flags | Prism::NodeFlags::NEWLINE
+                    else
+                      flags & ~Prism::NodeFlags::NEWLINE
+                    end
+        node.copy(flags: new_flags)
+      end
+    end
+  end
+end