@ai-ecoverse/wasix-ruby 3.4.11-3 → 3.4.11-5

package/lib/ruby/3.4.11/prism/translation/parser.rb

@@ -1,374 +0,0 @@
-# frozen_string_literal: true
-# :markup: markdown
-
-begin
-  required_version = ">= 3.3.7.2"
-  gem "parser", required_version
-  require "parser"
-rescue LoadError
-  warn(<<~MSG)
-    Error: Unable to load parser #{required_version}. \
-    Add `gem "parser"` to your Gemfile or run `bundle update parser`.
-  MSG
-  exit(1)
-end
-
-module Prism
-  module Translation
-    # This class is the entry-point for converting a prism syntax tree into the
-    # whitequark/parser gem's syntax tree. It inherits from the base parser for
-    # the parser gem, and overrides the parse* methods to parse with prism and
-    # then translate.
-    #
-    # Note that this version of the parser always parses using the latest
-    # version of Ruby syntax supported by Prism. If you want specific version
-    # support, use one of the version-specific subclasses, such as
-    # `Prism::Translation::Parser34`. If you want to parse using the same
-    # version of Ruby syntax as the currently running version of Ruby, use
-    # `Prism::Translation::ParserCurrent`.
-    class Parser < ::Parser::Base
-      Diagnostic = ::Parser::Diagnostic # :nodoc:
-      private_constant :Diagnostic
-
-      # The parser gem has a list of diagnostics with a hard-coded set of error
-      # messages. We create our own diagnostic class in order to set our own
-      # error messages.
-      class PrismDiagnostic < Diagnostic
-        # This is the cached message coming from prism.
-        attr_reader :message
-
-        # Initialize a new diagnostic with the given message and location.
-        def initialize(message, level, reason, location)
-          @message = message
-          super(level, reason, {}, location, [])
-        end
-      end
-
-      Racc_debug_parser = false # :nodoc:
-
-      # The `builder` argument is used to create the parser using our custom builder class by default.
-      #
-      # By using the `:parser` keyword argument, you can translate in a way that is compatible with
-      # the Parser gem using any parser.
-      #
-      # For example, in RuboCop for Ruby LSP, the following approach can be used to improve performance
-      # by reusing a pre-parsed `Prism::ParseLexResult`:
-      #
-      #   class PrismPreparsed
-      #     def initialize(prism_result)
-      #       @prism_result = prism_result
-      #     end
-      #
-      #     def parse_lex(source, **options)
-      #       @prism_result
-      #     end
-      #   end
-      #
-      #   prism_preparsed = PrismPreparsed.new(prism_result)
-      #
-      #   Prism::Translation::Ruby34.new(builder, parser: prism_preparsed)
-      #
-      # In an object passed to the `:parser` keyword argument, the `parse` and `parse_lex` methods
-      # should be implemented as needed.
-      #
-      def initialize(builder = Prism::Translation::Parser::Builder.new, parser: Prism)
-        if !builder.is_a?(Prism::Translation::Parser::Builder)
-          warn(<<~MSG, uplevel: 1, category: :deprecated)
-            [deprecation]: The builder passed to `Prism::Translation::Parser.new` is not a \
-            `Prism::Translation::Parser::Builder` subclass. This will raise in the next major version.
-          MSG
-        end
-        @parser = parser
-
-        super(builder)
-      end
-
-      def version # :nodoc:
-        35
-      end
-
-      # The default encoding for Ruby files is UTF-8.
-      def default_encoding
-        Encoding::UTF_8
-      end
-
-      def yyerror # :nodoc:
-      end
-
-      # Parses a source buffer and returns the AST.
-      def parse(source_buffer)
-        @source_buffer = source_buffer
-        source = source_buffer.source
-
-        offset_cache = build_offset_cache(source)
-        result = unwrap(@parser.parse(source, **prism_options), offset_cache)
-
-        build_ast(result.value, offset_cache)
-      ensure
-        @source_buffer = nil
-      end
-
-      # Parses a source buffer and returns the AST and the source code comments.
-      def parse_with_comments(source_buffer)
-        @source_buffer = source_buffer
-        source = source_buffer.source
-
-        offset_cache = build_offset_cache(source)
-        result = unwrap(@parser.parse(source, **prism_options), offset_cache)
-
-        [
-          build_ast(result.value, offset_cache),
-          build_comments(result.comments, offset_cache)
-        ]
-      ensure
-        @source_buffer = nil
-      end
-
-      # Parses a source buffer and returns the AST, the source code comments,
-      # and the tokens emitted by the lexer.
-      def tokenize(source_buffer, recover = false)
-        @source_buffer = source_buffer
-        source = source_buffer.source
-
-        offset_cache = build_offset_cache(source)
-        result =
-          begin
-            unwrap(@parser.parse_lex(source, **prism_options), offset_cache)
-          rescue ::Parser::SyntaxError
-            raise if !recover
-          end
-
-        program, tokens = result.value
-        ast = build_ast(program, offset_cache) if result.success?
-
-        [
-          ast,
-          build_comments(result.comments, offset_cache),
-          build_tokens(tokens, offset_cache)
-        ]
-      ensure
-        @source_buffer = nil
-      end
-
-      # Since prism resolves num params for us, we don't need to support this
-      # kind of logic here.
-      def try_declare_numparam(node)
-        node.children[0].match?(/\A_[1-9]\z/)
-      end
-
-      private
-
-      # This is a hook to allow consumers to disable some errors if they don't
-      # want them to block creating the syntax tree.
-      def valid_error?(error)
-        true
-      end
-
-      # This is a hook to allow consumers to disable some warnings if they don't
-      # want them to block creating the syntax tree.
-      def valid_warning?(warning)
-        true
-      end
-
-      # Build a diagnostic from the given prism parse error.
-      def error_diagnostic(error, offset_cache)
-        location = error.location
-        diagnostic_location = build_range(location, offset_cache)
-
-        case error.type
-        when :argument_block_multi
-          Diagnostic.new(:error, :block_and_blockarg, {}, diagnostic_location, [])
-        when :argument_formal_constant
-          Diagnostic.new(:error, :argument_const, {}, diagnostic_location, [])
-        when :argument_formal_class
-          Diagnostic.new(:error, :argument_cvar, {}, diagnostic_location, [])
-        when :argument_formal_global
-          Diagnostic.new(:error, :argument_gvar, {}, diagnostic_location, [])
-        when :argument_formal_ivar
-          Diagnostic.new(:error, :argument_ivar, {}, diagnostic_location, [])
-        when :argument_no_forwarding_amp
-          Diagnostic.new(:error, :no_anonymous_blockarg, {}, diagnostic_location, [])
-        when :argument_no_forwarding_star
-          Diagnostic.new(:error, :no_anonymous_restarg, {}, diagnostic_location, [])
-        when :argument_no_forwarding_star_star
-          Diagnostic.new(:error, :no_anonymous_kwrestarg, {}, diagnostic_location, [])
-        when :begin_lonely_else
-          location = location.copy(length: 4)
-          diagnostic_location = build_range(location, offset_cache)
-          Diagnostic.new(:error, :useless_else, {}, diagnostic_location, [])
-        when :class_name, :module_name
-          Diagnostic.new(:error, :module_name_const, {}, diagnostic_location, [])
-        when :class_in_method
-          Diagnostic.new(:error, :class_in_def, {}, diagnostic_location, [])
-        when :def_endless_setter
-          Diagnostic.new(:error, :endless_setter, {}, diagnostic_location, [])
-        when :embdoc_term
-          Diagnostic.new(:error, :embedded_document, {}, diagnostic_location, [])
-        when :incomplete_variable_class, :incomplete_variable_class_3_3
-          location = location.copy(length: location.length + 1)
-          diagnostic_location = build_range(location, offset_cache)
-
-          Diagnostic.new(:error, :cvar_name, { name: location.slice }, diagnostic_location, [])
-        when :incomplete_variable_instance, :incomplete_variable_instance_3_3
-          location = location.copy(length: location.length + 1)
-          diagnostic_location = build_range(location, offset_cache)
-
-          Diagnostic.new(:error, :ivar_name, { name: location.slice }, diagnostic_location, [])
-        when :invalid_variable_global, :invalid_variable_global_3_3
-          Diagnostic.new(:error, :gvar_name, { name: location.slice }, diagnostic_location, [])
-        when :module_in_method
-          Diagnostic.new(:error, :module_in_def, {}, diagnostic_location, [])
-        when :numbered_parameter_ordinary
-          Diagnostic.new(:error, :ordinary_param_defined, {}, diagnostic_location, [])
-        when :numbered_parameter_outer_scope
-          Diagnostic.new(:error, :numparam_used_in_outer_scope, {}, diagnostic_location, [])
-        when :parameter_circular
-          Diagnostic.new(:error, :circular_argument_reference, { var_name: location.slice }, diagnostic_location, [])
-        when :parameter_name_repeat
-          Diagnostic.new(:error, :duplicate_argument, {}, diagnostic_location, [])
-        when :parameter_numbered_reserved
-          Diagnostic.new(:error, :reserved_for_numparam, { name: location.slice }, diagnostic_location, [])
-        when :regexp_unknown_options
-          Diagnostic.new(:error, :regexp_options, { options: location.slice[1..] }, diagnostic_location, [])
-        when :singleton_for_literals
-          Diagnostic.new(:error, :singleton_literal, {}, diagnostic_location, [])
-        when :string_literal_eof
-          Diagnostic.new(:error, :string_eof, {}, diagnostic_location, [])
-        when :unexpected_token_ignore
-          Diagnostic.new(:error, :unexpected_token, { token: location.slice }, diagnostic_location, [])
-        when :write_target_in_method
-          Diagnostic.new(:error, :dynamic_const, {}, diagnostic_location, [])
-        else
-          PrismDiagnostic.new(error.message, :error, error.type, diagnostic_location)
-        end
-      end
-
-      # Build a diagnostic from the given prism parse warning.
-      def warning_diagnostic(warning, offset_cache)
-        diagnostic_location = build_range(warning.location, offset_cache)
-
-        case warning.type
-        when :ambiguous_first_argument_plus
-          Diagnostic.new(:warning, :ambiguous_prefix, { prefix: "+" }, diagnostic_location, [])
-        when :ambiguous_first_argument_minus
-          Diagnostic.new(:warning, :ambiguous_prefix, { prefix: "-" }, diagnostic_location, [])
-        when :ambiguous_prefix_ampersand
-          Diagnostic.new(:warning, :ambiguous_prefix, { prefix: "&" }, diagnostic_location, [])
-        when :ambiguous_prefix_star
-          Diagnostic.new(:warning, :ambiguous_prefix, { prefix: "*" }, diagnostic_location, [])
-        when :ambiguous_prefix_star_star
-          Diagnostic.new(:warning, :ambiguous_prefix, { prefix: "**" }, diagnostic_location, [])
-        when :ambiguous_slash
-          Diagnostic.new(:warning, :ambiguous_regexp, {}, diagnostic_location, [])
-        when :dot_dot_dot_eol
-          Diagnostic.new(:warning, :triple_dot_at_eol, {}, diagnostic_location, [])
-        when :duplicated_hash_key
-          # skip, parser does this on its own
-        else
-          PrismDiagnostic.new(warning.message, :warning, warning.type, diagnostic_location)
-        end
-      end
-
-      # If there was a error generated during the parse, then raise an
-      # appropriate syntax error. Otherwise return the result.
-      def unwrap(result, offset_cache)
-        result.errors.each do |error|
-          next unless valid_error?(error)
-          diagnostics.process(error_diagnostic(error, offset_cache))
-        end
-
-        result.warnings.each do |warning|
-          next unless valid_warning?(warning)
-          diagnostic = warning_diagnostic(warning, offset_cache)
-          diagnostics.process(diagnostic) if diagnostic
-        end
-
-        result
-      end
-
-      # Prism deals with offsets in bytes, while the parser gem deals with
-      # offsets in characters. We need to handle this conversion in order to
-      # build the parser gem AST.
-      #
-      # If the bytesize of the source is the same as the length, then we can
-      # just use the offset directly. Otherwise, we build an array where the
-      # index is the byte offset and the value is the character offset.
-      def build_offset_cache(source)
-        if source.bytesize == source.length
-          -> (offset) { offset }
-        else
-          offset_cache = []
-          offset = 0
-
-          source.each_char do |char|
-            char.bytesize.times { offset_cache << offset }
-            offset += 1
-          end
-
-          offset_cache << offset
-        end
-      end
-
-      # Build the parser gem AST from the prism AST.
-      def build_ast(program, offset_cache)
-        program.accept(Compiler.new(self, offset_cache))
-      end
-
-      # Build the parser gem comments from the prism comments.
-      def build_comments(comments, offset_cache)
-        comments.map do |comment|
-          ::Parser::Source::Comment.new(build_range(comment.location, offset_cache))
-        end
-      end
-
-      # Build the parser gem tokens from the prism tokens.
-      def build_tokens(tokens, offset_cache)
-        Lexer.new(source_buffer, tokens, offset_cache).to_a
-      end
-
-      # Build a range from a prism location.
-      def build_range(location, offset_cache)
-        ::Parser::Source::Range.new(
-          source_buffer,
-          offset_cache[location.start_offset],
-          offset_cache[location.end_offset]
-        )
-      end
-
-      # Options for how prism should parse/lex the source.
-      def prism_options
-        options = {
-          filepath: @source_buffer.name,
-          version: convert_for_prism(version),
-          partial_script: true,
-        }
-        # The parser gem always encodes to UTF-8, unless it is binary.
-        # https://github.com/whitequark/parser/blob/v3.3.6.0/lib/parser/source/buffer.rb#L80-L107
-        options[:encoding] = false if @source_buffer.source.encoding != Encoding::BINARY
-
-        options
-      end
-
-      # Converts the version format handled by Parser to the format handled by Prism.
-      def convert_for_prism(version)
-        case version
-        when 33
-          "3.3.1"
-        when 34
-          "3.4.0"
-        when 35
-          "3.5.0"
-        else
-          "latest"
-        end
-      end
-
-      require_relative "parser/builder"
-      require_relative "parser/compiler"
-      require_relative "parser/lexer"
-
-      private_constant :Compiler
-      private_constant :Lexer
-    end
-  end
-end

package/lib/ruby/3.4.11/prism/translation/parser33.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-# :markup: markdown
-
-module Prism
-  module Translation
-    # This class is the entry-point for Ruby 3.3 of `Prism::Translation::Parser`.
-    class Parser33 < Parser
-      def version # :nodoc:
-        33
-      end
-    end
-  end
-end

package/lib/ruby/3.4.11/prism/translation/parser34.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-# :markup: markdown
-
-module Prism
-  module Translation
-    # This class is the entry-point for Ruby 3.4 of `Prism::Translation::Parser`.
-    class Parser34 < Parser
-      def version # :nodoc:
-        34
-      end
-    end
-  end
-end

package/lib/ruby/3.4.11/prism/translation/parser35.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-# :markup: markdown
-
-module Prism
-  module Translation
-    # This class is the entry-point for Ruby 3.5 of `Prism::Translation::Parser`.
-    class Parser35 < Parser
-      def version # :nodoc:
-        35
-      end
-    end
-  end
-end

package/lib/ruby/3.4.11/prism/translation/parser_current.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-# :markup: markdown
-# typed: ignore
-
-#
-module Prism
-  module Translation
-    case RUBY_VERSION
-    when /^3\.3\./
-      ParserCurrent = Parser33
-    when /^3\.4\./
-      ParserCurrent = Parser34
-    when /^3\.5\./
-      ParserCurrent = Parser35
-    else
-      # Keep this in sync with released Ruby.
-      parser = Parser34
-      major, minor, _patch = Gem::Version.new(RUBY_VERSION).segments
-      warn "warning: `Prism::Translation::Current` is loading #{parser.name}, " \
-           "but you are running #{major}.#{minor}."
-      ParserCurrent = parser
-    end
-  end
-end

package/lib/ruby/3.4.11/prism/translation/ripper/sexp.rb

@@ -1,126 +0,0 @@
-# frozen_string_literal: true
-# :markup: markdown
-
-require_relative "../ripper"
-
-module Prism
-  module Translation
-    class Ripper
-      # This class mirrors the ::Ripper::SexpBuilder subclass of ::Ripper that
-      # returns the arrays of [type, *children].
-      class SexpBuilder < Ripper
-        # :stopdoc:
-
-        attr_reader :error
-
-        private
-
-        def dedent_element(e, width)
-          if (n = dedent_string(e[1], width)) > 0
-            e[2][1] += n
-          end
-          e
-        end
-
-        def on_heredoc_dedent(val, width)
-          sub = proc do |cont|
-            cont.map! do |e|
-              if Array === e
-                case e[0]
-                when :@tstring_content
-                  e = dedent_element(e, width)
-                when /_add\z/
-                  e[1] = sub[e[1]]
-                end
-              elsif String === e
-                dedent_string(e, width)
-              end
-              e
-            end
-          end
-          sub[val]
-          val
-        end
-
-        events = private_instance_methods(false).grep(/\Aon_/) {$'.to_sym}
-        (PARSER_EVENTS - events).each do |event|
-          module_eval(<<-End, __FILE__, __LINE__ + 1)
-            def on_#{event}(*args)
-              args.unshift :#{event}
-            end
-          End
-        end
-
-        SCANNER_EVENTS.each do |event|
-          module_eval(<<-End, __FILE__, __LINE__ + 1)
-            def on_#{event}(tok)
-              [:@#{event}, tok, [lineno(), column()]]
-            end
-          End
-        end
-
-        def on_error(mesg)
-          @error = mesg
-        end
-        remove_method :on_parse_error
-        alias on_parse_error on_error
-        alias compile_error on_error
-
-        # :startdoc:
-      end
-
-      # This class mirrors the ::Ripper::SexpBuilderPP subclass of ::Ripper that
-      # returns the same values as ::Ripper::SexpBuilder except with a couple of
-      # niceties that flatten linked lists into arrays.
-      class SexpBuilderPP < SexpBuilder
-        # :stopdoc:
-
-        private
-
-        def on_heredoc_dedent(val, width)
-          val.map! do |e|
-            next e if Symbol === e and /_content\z/ =~ e
-            if Array === e and e[0] == :@tstring_content
-              e = dedent_element(e, width)
-            elsif String === e
-              dedent_string(e, width)
-            end
-            e
-          end
-          val
-        end
-
-        def _dispatch_event_new
-          []
-        end
-
-        def _dispatch_event_push(list, item)
-          list.push item
-          list
-        end
-
-        def on_mlhs_paren(list)
-          [:mlhs, *list]
-        end
-
-        def on_mlhs_add_star(list, star)
-          list.push([:rest_param, star])
-        end
-
-        def on_mlhs_add_post(list, post)
-          list.concat(post)
-        end
-
-        PARSER_EVENT_TABLE.each do |event, arity|
-          if /_new\z/ =~ event and arity == 0
-            alias_method "on_#{event}", :_dispatch_event_new
-          elsif /_add\z/ =~ event
-            alias_method "on_#{event}", :_dispatch_event_push
-          end
-        end
-
-        # :startdoc:
-      end
-    end
-  end
-end

package/lib/ruby/3.4.11/prism/translation/ripper/shim.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-# This writes the prism ripper translation into the Ripper constant so that
-# users can transparently use Ripper without any changes.
-Ripper = Prism::Translation::Ripper