prism 0.29.0 → 1.3.0

data/lib/prism/debug.rb

@@ -1,249 +0,0 @@
-# frozen_string_literal: true
-
-module Prism
-  # This module is used for testing and debugging and is not meant to be used by
-  # consumers of this library.
-  module Debug
-    # A wrapper around a RubyVM::InstructionSequence that provides a more
-    # convenient interface for accessing parts of the iseq.
-    class ISeq # :nodoc:
-      attr_reader :parts
-
-      def initialize(parts)
-        @parts = parts
-      end
-
-      def type
-        parts[0]
-      end
-
-      def local_table
-        parts[10]
-      end
-
-      def instructions
-        parts[13]
-      end
-
-      def each_child
-        instructions.each do |instruction|
-          # Only look at arrays. Other instructions are line numbers or
-          # tracepoint events.
-          next unless instruction.is_a?(Array)
-
-          instruction.each do |opnd|
-            # Only look at arrays. Other operands are literals.
-            next unless opnd.is_a?(Array)
-
-            # Only look at instruction sequences. Other operands are literals.
-            next unless opnd[0] == "YARVInstructionSequence/SimpleDataFormat"
-
-            yield ISeq.new(opnd)
-          end
-        end
-      end
-    end
-
-    private_constant :ISeq
-
-    # :call-seq:
-    #   Debug::cruby_locals(source) -> Array
-    #
-    # For the given source, compiles with CRuby and returns a list of all of the
-    # sets of local variables that were encountered.
-    def self.cruby_locals(source)
-      verbose, $VERBOSE = $VERBOSE, nil
-
-      begin
-        locals = [] #: Array[Array[Symbol | Integer]]
-        stack = [ISeq.new(RubyVM::InstructionSequence.compile(source).to_a)]
-
-        while (iseq = stack.pop)
-          names = [*iseq.local_table]
-          names.map!.with_index do |name, index|
-            # When an anonymous local variable is present in the iseq's local
-            # table, it is represented as the stack offset from the top.
-            # However, when these are dumped to binary and read back in, they
-            # are replaced with the symbol :#arg_rest. To consistently handle
-            # this, we replace them here with their index.
-            if name == :"#arg_rest"
-              names.length - index + 1
-            else
-              name
-            end
-          end
-
-          locals << names
-          iseq.each_child { |child| stack << child }
-        end
-
-        locals
-      ensure
-        $VERBOSE = verbose
-      end
-    end
-
-    # Used to hold the place of a local that will be in the local table but
-    # cannot be accessed directly from the source code. For example, the
-    # iteration variable in a for loop or the positional parameter on a method
-    # definition that is destructured.
-    AnonymousLocal = Object.new
-    private_constant :AnonymousLocal
-
-    # :call-seq:
-    #   Debug::prism_locals(source) -> Array
-    #
-    # For the given source, parses with prism and returns a list of all of the
-    # sets of local variables that were encountered.
-    def self.prism_locals(source)
-      locals = [] #: Array[Array[Symbol | Integer]]
-      stack = [Prism.parse(source).value] #: Array[Prism::node]
-
-      while (node = stack.pop)
-        case node
-        when BlockNode, DefNode, LambdaNode
-          names = node.locals
-          params =
-            if node.is_a?(DefNode)
-              node.parameters
-            elsif node.parameters.is_a?(NumberedParametersNode)
-              nil
-            else
-              node.parameters&.parameters
-            end
-
-          # prism places parameters in the same order that they appear in the
-          # source. CRuby places them in the order that they need to appear
-          # according to their own internal calling convention. We mimic that
-          # order here so that we can compare properly.
-          if params
-            sorted = [
-              *params.requireds.map do |required|
-                if required.is_a?(RequiredParameterNode)
-                  required.name
-                else
-                  AnonymousLocal
-                end
-              end,
-              *params.optionals.map(&:name),
-              *((params.rest.name || :*) if params.rest && !params.rest.is_a?(ImplicitRestNode)),
-              *params.posts.map do |post|
-                if post.is_a?(RequiredParameterNode)
-                  post.name
-                else
-                  AnonymousLocal
-                end
-              end,
-              *params.keywords.grep(RequiredKeywordParameterNode).map(&:name),
-              *params.keywords.grep(OptionalKeywordParameterNode).map(&:name),
-            ]
-
-            sorted << AnonymousLocal if params.keywords.any?
-
-            if params.keyword_rest.is_a?(ForwardingParameterNode)
-              sorted.push(:*, :**, :&, :"...")
-            elsif params.keyword_rest.is_a?(KeywordRestParameterNode)
-              sorted << (params.keyword_rest.name || :**)
-            end
-
-            # Recurse down the parameter tree to find any destructured
-            # parameters and add them after the other parameters.
-            param_stack = params.requireds.concat(params.posts).grep(MultiTargetNode).reverse
-            while (param = param_stack.pop)
-              case param
-              when MultiTargetNode
-                param_stack.concat(param.rights.reverse)
-                param_stack << param.rest if param.rest&.expression && !sorted.include?(param.rest.expression.name)
-                param_stack.concat(param.lefts.reverse)
-              when RequiredParameterNode
-                sorted << param.name
-              when SplatNode
-                sorted << param.expression.name
-              end
-            end
-
-            if params.block
-              sorted << (params.block.name || :&)
-            end
-
-            names = sorted.concat(names - sorted)
-          end
-
-          names.map!.with_index do |name, index|
-            if name == AnonymousLocal
-              names.length - index + 1
-            else
-              name
-            end
-          end
-
-          locals << names
-        when ClassNode, ModuleNode, ProgramNode, SingletonClassNode
-          locals << node.locals
-        when ForNode
-          locals << [2]
-        when PostExecutionNode
-          locals.push([], [])
-        when InterpolatedRegularExpressionNode
-          locals << [] if node.once?
-        end
-
-        stack.concat(node.compact_child_nodes)
-      end
-
-      locals
-    end
-
-    # :call-seq:
-    #   Debug::newlines(source) -> Array
-    #
-    # For the given source string, return the byte offsets of every newline in
-    # the source.
-    def self.newlines(source)
-      Prism.parse(source).source.offsets
-    end
-
-    # A wrapping around prism's internal encoding data structures. This is used
-    # for reflection and debugging purposes.
-    class Encoding
-      # The name of the encoding, that can be passed to Encoding.find.
-      attr_reader :name
-
-      # Initialize a new encoding with the given name and whether or not it is
-      # a multibyte encoding.
-      def initialize(name, multibyte)
-        @name = name
-        @multibyte = multibyte
-      end
-
-      # Whether or not the encoding is a multibyte encoding.
-      def multibyte?
-        @multibyte
-      end
-
-      # Returns the number of bytes of the first character in the source string,
-      # if it is valid for the encoding. Otherwise, returns 0.
-      def width(source)
-        Encoding._width(name, source)
-      end
-
-      # Returns true if the first character in the source string is a valid
-      # alphanumeric character for the encoding.
-      def alnum?(source)
-        Encoding._alnum?(name, source)
-      end
-
-      # Returns true if the first character in the source string is a valid
-      # alphabetic character for the encoding.
-      def alpha?(source)
-        Encoding._alpha?(name, source)
-      end
-
-      # Returns true if the first character in the source string is a valid
-      # uppercase character for the encoding.
-      def upper?(source)
-        Encoding._upper?(name, source)
-      end
-    end
-  end
-end

data/lib/prism/translation/parser/rubocop.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-# typed: ignore
-
-warn "WARN: Prism is directly supported since RuboCop 1.62. The `prism/translation/parser/rubocop` file is deprecated."
-
-require "parser"
-require "rubocop"
-
-require_relative "../../prism"
-require_relative "../parser"
-
-module Prism
-  module Translation
-    class Parser
-      # This is the special version numbers that should be used in RuboCop
-      # configuration files to trigger using prism.
-
-      # For Ruby 3.3
-      VERSION_3_3 = 80_82_73_83_77.33
-
-      # For Ruby 3.4
-      VERSION_3_4 = 80_82_73_83_77.34
-
-      # This module gets prepended into RuboCop::AST::ProcessedSource.
-      module ProcessedSource
-        # This condition is compatible with rubocop-ast versions up to 1.30.0.
-        if RuboCop::AST::ProcessedSource.instance_method(:parser_class).arity == 1
-          # Redefine parser_class so that we can inject the prism parser into the
-          # list of known parsers.
-          def parser_class(ruby_version)
-            if ruby_version == Prism::Translation::Parser::VERSION_3_3
-              warn "WARN: Setting `TargetRubyVersion: 80_82_73_83_77.33` is deprecated. " \
-                   "Set to `ParserEngine: parser_prism` and `TargetRubyVersion: 3.3` instead."
-              require_relative "../parser33"
-              Prism::Translation::Parser33
-            elsif ruby_version == Prism::Translation::Parser::VERSION_3_4
-              warn "WARN: Setting `TargetRubyVersion: 80_82_73_83_77.34` is deprecated. " \
-                   "Set to `ParserEngine: parser_prism` and `TargetRubyVersion: 3.4` instead."
-              require_relative "../parser34"
-              Prism::Translation::Parser34
-            else
-              super
-            end
-          end
-        else
-          # Redefine parser_class so that we can inject the prism parser into the
-          # list of known parsers.
-          def parser_class(ruby_version, _parser_engine)
-            if ruby_version == Prism::Translation::Parser::VERSION_3_3
-              warn "WARN: Setting `TargetRubyVersion: 80_82_73_83_77.33` is deprecated. " \
-                   "Set to `ParserEngine: parser_prism` and `TargetRubyVersion: 3.3` instead."
-              require_relative "../parser33"
-              Prism::Translation::Parser33
-            elsif ruby_version == Prism::Translation::Parser::VERSION_3_4
-              warn "WARN: Setting `TargetRubyVersion: 80_82_73_83_77.34` is deprecated. " \
-                   "Set to `ParserEngine: parser_prism` and `TargetRubyVersion: 3.4` instead."
-              require_relative "../parser34"
-              Prism::Translation::Parser34
-            else
-              super
-            end
-          end
-        end
-      end
-    end
-  end
-end
-
-# :stopdoc:
-RuboCop::AST::ProcessedSource.prepend(Prism::Translation::Parser::ProcessedSource)
-known_rubies = RuboCop::TargetRuby.const_get(:KNOWN_RUBIES)
-RuboCop::TargetRuby.send(:remove_const, :KNOWN_RUBIES)
-RuboCop::TargetRuby::KNOWN_RUBIES = [*known_rubies, Prism::Translation::Parser::VERSION_3_3].freeze

data/src/util/pm_string_list.c

@@ -1,28 +0,0 @@
-#include "prism/util/pm_string_list.h"
-
-/**
- * Append a pm_string_t to the given string list.
- */
-void
-pm_string_list_append(pm_string_list_t *string_list, pm_string_t *string) {
-    if (string_list->length + 1 > string_list->capacity) {
-        if (string_list->capacity == 0) {
-            string_list->capacity = 1;
-        } else {
-            string_list->capacity *= 2;
-        }
-
-        string_list->strings = xrealloc(string_list->strings, string_list->capacity * sizeof(pm_string_t));
-        if (string_list->strings == NULL) abort();
-    }
-
-    string_list->strings[string_list->length++] = *string;
-}
-
-/**
- * Free the memory associated with the string list
- */
-void
-pm_string_list_free(pm_string_list_t *string_list) {
-    xfree(string_list->strings);
-}