prism 2.0.0.rc1-x86_64-linux-gnu

data/lib/prism/pattern.rb

@@ -0,0 +1,314 @@
+# frozen_string_literal: true
+# :markup: markdown
+#--
+# rbs_inline: enabled
+
+module Prism
+  # A pattern is an object that wraps a Ruby pattern matching expression. The
+  # expression would normally be passed to an `in` clause within a `case`
+  # expression or a rightward assignment expression. For example, in the
+  # following snippet:
+  #
+  #     case node
+  #     in ConstantPathNode[ConstantReadNode[name: :Prism], ConstantReadNode[name: :Pattern]]
+  #     end
+  #
+  # the pattern is the <tt>ConstantPathNode[...]</tt> expression.
+  #
+  # The pattern gets compiled into an object that responds to #call by running
+  # the #compile method. This method itself will run back through Prism to
+  # parse the expression into a tree, then walk the tree to generate the
+  # necessary callable objects. For example, if you wanted to compile the
+  # expression above into a callable, you would:
+  #
+  #     callable = Prism::Pattern.new("ConstantPathNode[ConstantReadNode[name: :Prism], ConstantReadNode[name: :Pattern]]").compile
+  #     callable.call(node)
+  #
+  # The callable object returned by #compile is guaranteed to respond to #call
+  # with a single argument, which is the node to match against. It also is
+  # guaranteed to respond to #===, which means it itself can be used in a `case`
+  # expression, as in:
+  #
+  #     case node
+  #     when callable
+  #     end
+  #
+  # If the query given to the initializer cannot be compiled into a valid
+  # matcher (either because of a syntax error or because it is using syntax we
+  # do not yet support) then a Prism::Pattern::CompilationError will be
+  # raised.
+  class Pattern
+    # Raised when the query given to a pattern is either invalid Ruby syntax or
+    # is using syntax that we don't yet support.
+    class CompilationError < StandardError
+      # Create a new CompilationError with the given representation of the node
+      # that caused the error.
+      #
+      #: (String repr) -> void
+      def initialize(repr) # :nodoc:
+        super(<<~ERROR)
+          prism was unable to compile the pattern you provided into a usable
+          expression. It failed on to understand the node represented by:
+
+          #{repr}
+
+          Note that not all syntax supported by Ruby's pattern matching syntax
+          is also supported by prism's patterns. If you're using some syntax
+          that you believe should be supported, please open an issue on
+          GitHub at https://github.com/ruby/prism/issues/new.
+        ERROR
+      end
+    end
+
+    # The query that this pattern was initialized with.
+    attr_reader :query #: String
+    # @rbs @compiled: Proc?
+
+    # Create a new pattern with the given query. The query should be a string
+    # containing a Ruby pattern matching expression.
+    #
+    #: (String query) -> void
+    def initialize(query)
+      @query = query
+      @compiled = nil
+    end
+
+    # Compile the query into a callable object that can be used to match against
+    # nodes.
+    #
+    #: () -> Proc
+    def compile
+      result = Prism.parse("case nil\nin #{query}\nend")
+
+      case_match_node = result.value.statements.body.last
+      raise CompilationError, case_match_node.inspect unless case_match_node.is_a?(CaseMatchNode)
+
+      in_node = case_match_node.conditions.last
+      raise CompilationError, in_node.inspect unless in_node.is_a?(InNode)
+
+      compile_node(in_node.pattern)
+    end
+
+    # Scan the given node and all of its children for nodes that match the
+    # pattern. If a block is given, it will be called with each node that
+    # matches the pattern. If no block is given, an enumerator will be returned
+    # that will yield each node that matches the pattern.
+    #
+    #: (node root) -> Enumerator[node, void]
+    #: (node root) { (node) -> void } -> void
+    def scan(root, &blk)
+      return to_enum(:scan, root) unless block_given?
+
+      @compiled ||= compile
+      queue = [root]
+
+      while (node = queue.shift)
+        yield node if @compiled.call(node) # steep:ignore
+        queue.concat(node.compact_child_nodes)
+      end
+    end
+
+    private
+
+    # Shortcut for combining two procs into one that returns true if both return
+    # true.
+    #
+    #: (Proc left, Proc right) -> Proc
+    def combine_and(left, right) # :nodoc:
+      ->(other) { left.call(other) && right.call(other) }
+    end
+
+    # Shortcut for combining two procs into one that returns true if either
+    # returns true.
+    #
+    #: (Proc left, Proc right) -> Proc
+    def combine_or(left, right) # :nodoc:
+      ->(other) { left.call(other) || right.call(other) }
+    end
+
+    # Raise an error because the given node is not supported. Note purposefully
+    # not typing this method since it is a no return method that Steep does not
+    # understand.
+    #
+    #: (node node) -> bot
+    def compile_error(node) # :nodoc:
+      raise CompilationError, node.inspect
+    end
+
+    # in [foo, bar, baz]
+    #
+    #: (ArrayPatternNode node) -> Proc
+    def compile_array_pattern_node(node) # :nodoc:
+      compile_error(node) if !node.rest.nil? || node.posts.any?
+
+      constant = node.constant
+      compiled_constant = compile_node(constant) if constant
+
+      preprocessed = node.requireds.map { |required| compile_node(required) }
+
+      compiled_requireds = ->(other) do
+        deconstructed = other.deconstruct
+
+        deconstructed.length == preprocessed.length &&
+          preprocessed
+            .zip(deconstructed)
+            .all? { |(matcher, value)| matcher.call(value) }
+      end
+
+      if compiled_constant
+        combine_and(compiled_constant, compiled_requireds)
+      else
+        compiled_requireds
+      end
+    end
+
+    # in foo | bar
+    #
+    #: (AlternationPatternNode node) -> Proc
+    def compile_alternation_pattern_node(node) # :nodoc:
+      combine_or(compile_node(node.left), compile_node(node.right))
+    end
+
+    # in Prism::ConstantReadNode
+    #
+    #: (ConstantPathNode node) -> Proc
+    def compile_constant_path_node(node) # :nodoc:
+      parent = node.parent
+
+      if (parent.is_a?(ConstantReadNode) || parent.is_a?(ConstantPathNode)) && parent.slice == Prism.name
+        name = node.name
+        raise CompilationError, node.inspect if name.nil?
+
+        compile_constant_name(node, name)
+      else
+        compile_error(node)
+      end
+    end
+
+    # in ConstantReadNode
+    # in String
+    #
+    #: (ConstantReadNode node) -> Proc
+    def compile_constant_read_node(node) # :nodoc:
+      compile_constant_name(node, node.name)
+    end
+
+    # Compile a name associated with a constant.
+    #
+    #: ((ConstantPathNode | ConstantReadNode) node, Symbol name) -> Proc
+    def compile_constant_name(node, name) # :nodoc:
+      if Prism.const_defined?(name, false)
+        clazz = Prism.const_get(name)
+
+        ->(other) { clazz === other }
+      elsif Object.const_defined?(name, false)
+        clazz = Object.const_get(name)
+
+        ->(other) { clazz === other }
+      else
+        compile_error(node)
+      end
+    end
+
+    # in InstanceVariableReadNode[name: Symbol]
+    # in { name: Symbol }
+    #
+    #: (HashPatternNode node) -> Proc
+    def compile_hash_pattern_node(node) # :nodoc:
+      compile_error(node) if node.rest
+
+      if (constant = node.constant)
+        compiled_constant = compile_node(constant)
+      end
+
+      preprocessed =
+        node.elements.to_h do |element|
+          key = element.key
+          if key.is_a?(SymbolNode)
+            [key.unescaped.to_sym, compile_node(element.value)]
+          else
+            raise CompilationError, element.inspect
+          end
+        end
+
+      compiled_keywords = ->(other) do
+        deconstructed = other.deconstruct_keys(preprocessed.keys)
+
+        preprocessed.all? do |keyword, matcher|
+          deconstructed.key?(keyword) && matcher.call(deconstructed[keyword])
+        end
+      end
+
+      if compiled_constant
+        combine_and(compiled_constant, compiled_keywords)
+      else
+        compiled_keywords
+      end
+    end
+
+    # in nil
+    #
+    #: (NilNode node) -> Proc
+    def compile_nil_node(node) # :nodoc:
+      ->(attribute) { attribute.nil? }
+    end
+
+    # in /foo/
+    #
+    #: (RegularExpressionNode node) -> Proc
+    def compile_regular_expression_node(node) # :nodoc:
+      regexp = Regexp.new(node.unescaped, node.closing[1..])
+
+      ->(attribute) { regexp === attribute }
+    end
+
+    # in ""
+    # in "foo"
+    #
+    #: (StringNode node) -> Proc
+    def compile_string_node(node) # :nodoc:
+      string = node.unescaped
+
+      ->(attribute) { string === attribute }
+    end
+
+    # in :+
+    # in :foo
+    #
+    #: (SymbolNode node) -> Proc
+    def compile_symbol_node(node) # :nodoc:
+      symbol = node.unescaped.to_sym
+
+      ->(attribute) { symbol === attribute }
+    end
+
+    # Compile any kind of node. Dispatch out to the individual compilation
+    # methods based on the type of node.
+    #
+    #: (node node) -> Proc
+    def compile_node(node) # :nodoc:
+      case node
+      when AlternationPatternNode
+        compile_alternation_pattern_node(node)
+      when ArrayPatternNode
+        compile_array_pattern_node(node)
+      when ConstantPathNode
+        compile_constant_path_node(node)
+      when ConstantReadNode
+        compile_constant_read_node(node)
+      when HashPatternNode
+        compile_hash_pattern_node(node)
+      when NilNode
+        compile_nil_node(node)
+      when RegularExpressionNode
+        compile_regular_expression_node(node)
+      when StringNode
+        compile_string_node(node)
+      when SymbolNode
+        compile_symbol_node(node)
+      else
+        compile_error(node)
+      end
+    end
+  end
+end

data/lib/prism/polyfill/append_as_bytes.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# Polyfill for String#append_as_bytes, which didn't exist until Ruby 3.4.
+if !("".respond_to?(:append_as_bytes))
+  String.include(
+    Module.new {
+      def append_as_bytes(*args)
+        args.each do |arg|
+          arg = Integer === arg ? [arg].pack("C") : arg.b
+          self.<<(arg) # steep:ignore
+        end
+      end
+    }
+  )
+end

data/lib/prism/polyfill/byteindex.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+# Polyfill for String#byteindex, which didn't exist until Ruby 3.2.
+if !("".respond_to?(:byteindex))
+  String.include(
+    Module.new {
+      def byteindex(needle, offset = 0)
+        charindex = index(needle, offset)
+        slice(0...charindex).bytesize if charindex
+      end
+    }
+  )
+end

data/lib/prism/polyfill/scan_byte.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "strscan"
+
+# Polyfill for StringScanner#scan_byte, which didn't exist until Ruby 3.4.
+if !(StringScanner.method_defined?(:scan_byte))
+  StringScanner.include(
+    Module.new {
+      def scan_byte # :nodoc:
+        get_byte&.b&.ord
+      end
+    }
+  )
+end

data/lib/prism/polyfill/unpack1.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# Polyfill for String#unpack1 with the offset parameter. Not all Ruby engines
+# have Method#parameters implemented, so we check the arity instead if
+# necessary.
+if (unpack1 = String.instance_method(:unpack1)).respond_to?(:parameters) ? unpack1.parameters.none? { |_, name| name == :offset } : (unpack1.arity == 1)
+  String.prepend(
+    Module.new {
+      def unpack1(format, offset: 0) # :nodoc:
+        offset == 0 ? super(format) : self[offset..].unpack1(format) # steep:ignore
+      end
+    }
+  )
+end

data/lib/prism/polyfill/warn.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# Polyfill for Kernel#warn with the category parameter. Not all Ruby engines
+# have Method#parameters implemented, so we check the arity instead if
+# necessary.
+if (method = Kernel.instance_method(:warn)).respond_to?(:parameters) ? method.parameters.none? { |_, name| name == :category } : (method.arity == -1)
+  Kernel.prepend(
+    Module.new {
+      def warn(*msgs, uplevel: nil, category: nil) # :nodoc:
+        case uplevel
+        when nil
+          super(*msgs)
+        when Integer
+          super(*msgs, uplevel: uplevel + 1)
+        else
+          super(*msgs, uplevel: uplevel.to_int + 1)
+        end
+      end
+    }
+  )
+
+  Object.prepend(
+    Module.new {
+      def warn(*msgs, uplevel: nil, category: nil) # :nodoc:
+        case uplevel
+        when nil
+          super(*msgs)
+        when Integer
+          super(*msgs, uplevel: uplevel + 1)
+        else
+          super(*msgs, uplevel: uplevel.to_int + 1)
+        end
+      end
+    }
+  )
+end