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

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

@@ -1,820 +0,0 @@
-# frozen_string_literal: true
-# :markup: markdown
-
-require "strscan"
-require_relative "../../polyfill/append_as_bytes"
-require_relative "../../polyfill/scan_byte"
-
-module Prism
-  module Translation
-    class Parser
-      # Accepts a list of prism tokens and converts them into the expected
-      # format for the parser gem.
-      class Lexer
-        # These tokens are always skipped
-        TYPES_ALWAYS_SKIP = Set.new(%i[IGNORED_NEWLINE __END__ EOF])
-        private_constant :TYPES_ALWAYS_SKIP
-
-        # The direct translating of types between the two lexers.
-        TYPES = {
-          # These tokens should never appear in the output of the lexer.
-          MISSING: nil,
-          NOT_PROVIDED: nil,
-          EMBDOC_END: nil,
-          EMBDOC_LINE: nil,
-
-          # These tokens have more or less direct mappings.
-          AMPERSAND: :tAMPER2,
-          AMPERSAND_AMPERSAND: :tANDOP,
-          AMPERSAND_AMPERSAND_EQUAL: :tOP_ASGN,
-          AMPERSAND_DOT: :tANDDOT,
-          AMPERSAND_EQUAL: :tOP_ASGN,
-          BACK_REFERENCE: :tBACK_REF,
-          BACKTICK: :tXSTRING_BEG,
-          BANG: :tBANG,
-          BANG_EQUAL: :tNEQ,
-          BANG_TILDE: :tNMATCH,
-          BRACE_LEFT: :tLCURLY,
-          BRACE_RIGHT: :tRCURLY,
-          BRACKET_LEFT: :tLBRACK2,
-          BRACKET_LEFT_ARRAY: :tLBRACK,
-          BRACKET_LEFT_RIGHT: :tAREF,
-          BRACKET_LEFT_RIGHT_EQUAL: :tASET,
-          BRACKET_RIGHT: :tRBRACK,
-          CARET: :tCARET,
-          CARET_EQUAL: :tOP_ASGN,
-          CHARACTER_LITERAL: :tCHARACTER,
-          CLASS_VARIABLE: :tCVAR,
-          COLON: :tCOLON,
-          COLON_COLON: :tCOLON2,
-          COMMA: :tCOMMA,
-          COMMENT: :tCOMMENT,
-          CONSTANT: :tCONSTANT,
-          DOT: :tDOT,
-          DOT_DOT: :tDOT2,
-          DOT_DOT_DOT: :tDOT3,
-          EMBDOC_BEGIN: :tCOMMENT,
-          EMBEXPR_BEGIN: :tSTRING_DBEG,
-          EMBEXPR_END: :tSTRING_DEND,
-          EMBVAR: :tSTRING_DVAR,
-          EQUAL: :tEQL,
-          EQUAL_EQUAL: :tEQ,
-          EQUAL_EQUAL_EQUAL: :tEQQ,
-          EQUAL_GREATER: :tASSOC,
-          EQUAL_TILDE: :tMATCH,
-          FLOAT: :tFLOAT,
-          FLOAT_IMAGINARY: :tIMAGINARY,
-          FLOAT_RATIONAL: :tRATIONAL,
-          FLOAT_RATIONAL_IMAGINARY: :tIMAGINARY,
-          GLOBAL_VARIABLE: :tGVAR,
-          GREATER: :tGT,
-          GREATER_EQUAL: :tGEQ,
-          GREATER_GREATER: :tRSHFT,
-          GREATER_GREATER_EQUAL: :tOP_ASGN,
-          HEREDOC_START: :tSTRING_BEG,
-          HEREDOC_END: :tSTRING_END,
-          IDENTIFIER: :tIDENTIFIER,
-          INSTANCE_VARIABLE: :tIVAR,
-          INTEGER: :tINTEGER,
-          INTEGER_IMAGINARY: :tIMAGINARY,
-          INTEGER_RATIONAL: :tRATIONAL,
-          INTEGER_RATIONAL_IMAGINARY: :tIMAGINARY,
-          KEYWORD_ALIAS: :kALIAS,
-          KEYWORD_AND: :kAND,
-          KEYWORD_BEGIN: :kBEGIN,
-          KEYWORD_BEGIN_UPCASE: :klBEGIN,
-          KEYWORD_BREAK: :kBREAK,
-          KEYWORD_CASE: :kCASE,
-          KEYWORD_CLASS: :kCLASS,
-          KEYWORD_DEF: :kDEF,
-          KEYWORD_DEFINED: :kDEFINED,
-          KEYWORD_DO: :kDO,
-          KEYWORD_DO_LOOP: :kDO_COND,
-          KEYWORD_END: :kEND,
-          KEYWORD_END_UPCASE: :klEND,
-          KEYWORD_ENSURE: :kENSURE,
-          KEYWORD_ELSE: :kELSE,
-          KEYWORD_ELSIF: :kELSIF,
-          KEYWORD_FALSE: :kFALSE,
-          KEYWORD_FOR: :kFOR,
-          KEYWORD_IF: :kIF,
-          KEYWORD_IF_MODIFIER: :kIF_MOD,
-          KEYWORD_IN: :kIN,
-          KEYWORD_MODULE: :kMODULE,
-          KEYWORD_NEXT: :kNEXT,
-          KEYWORD_NIL: :kNIL,
-          KEYWORD_NOT: :kNOT,
-          KEYWORD_OR: :kOR,
-          KEYWORD_REDO: :kREDO,
-          KEYWORD_RESCUE: :kRESCUE,
-          KEYWORD_RESCUE_MODIFIER: :kRESCUE_MOD,
-          KEYWORD_RETRY: :kRETRY,
-          KEYWORD_RETURN: :kRETURN,
-          KEYWORD_SELF: :kSELF,
-          KEYWORD_SUPER: :kSUPER,
-          KEYWORD_THEN: :kTHEN,
-          KEYWORD_TRUE: :kTRUE,
-          KEYWORD_UNDEF: :kUNDEF,
-          KEYWORD_UNLESS: :kUNLESS,
-          KEYWORD_UNLESS_MODIFIER: :kUNLESS_MOD,
-          KEYWORD_UNTIL: :kUNTIL,
-          KEYWORD_UNTIL_MODIFIER: :kUNTIL_MOD,
-          KEYWORD_WHEN: :kWHEN,
-          KEYWORD_WHILE: :kWHILE,
-          KEYWORD_WHILE_MODIFIER: :kWHILE_MOD,
-          KEYWORD_YIELD: :kYIELD,
-          KEYWORD___ENCODING__: :k__ENCODING__,
-          KEYWORD___FILE__: :k__FILE__,
-          KEYWORD___LINE__: :k__LINE__,
-          LABEL: :tLABEL,
-          LABEL_END: :tLABEL_END,
-          LAMBDA_BEGIN: :tLAMBEG,
-          LESS: :tLT,
-          LESS_EQUAL: :tLEQ,
-          LESS_EQUAL_GREATER: :tCMP,
-          LESS_LESS: :tLSHFT,
-          LESS_LESS_EQUAL: :tOP_ASGN,
-          METHOD_NAME: :tFID,
-          MINUS: :tMINUS,
-          MINUS_EQUAL: :tOP_ASGN,
-          MINUS_GREATER: :tLAMBDA,
-          NEWLINE: :tNL,
-          NUMBERED_REFERENCE: :tNTH_REF,
-          PARENTHESIS_LEFT: :tLPAREN2,
-          PARENTHESIS_LEFT_PARENTHESES: :tLPAREN_ARG,
-          PARENTHESIS_RIGHT: :tRPAREN,
-          PERCENT: :tPERCENT,
-          PERCENT_EQUAL: :tOP_ASGN,
-          PERCENT_LOWER_I: :tQSYMBOLS_BEG,
-          PERCENT_LOWER_W: :tQWORDS_BEG,
-          PERCENT_UPPER_I: :tSYMBOLS_BEG,
-          PERCENT_UPPER_W: :tWORDS_BEG,
-          PERCENT_LOWER_X: :tXSTRING_BEG,
-          PLUS: :tPLUS,
-          PLUS_EQUAL: :tOP_ASGN,
-          PIPE_EQUAL: :tOP_ASGN,
-          PIPE: :tPIPE,
-          PIPE_PIPE: :tOROP,
-          PIPE_PIPE_EQUAL: :tOP_ASGN,
-          QUESTION_MARK: :tEH,
-          REGEXP_BEGIN: :tREGEXP_BEG,
-          REGEXP_END: :tSTRING_END,
-          SEMICOLON: :tSEMI,
-          SLASH: :tDIVIDE,
-          SLASH_EQUAL: :tOP_ASGN,
-          STAR: :tSTAR2,
-          STAR_EQUAL: :tOP_ASGN,
-          STAR_STAR: :tPOW,
-          STAR_STAR_EQUAL: :tOP_ASGN,
-          STRING_BEGIN: :tSTRING_BEG,
-          STRING_CONTENT: :tSTRING_CONTENT,
-          STRING_END: :tSTRING_END,
-          SYMBOL_BEGIN: :tSYMBEG,
-          TILDE: :tTILDE,
-          UAMPERSAND: :tAMPER,
-          UCOLON_COLON: :tCOLON3,
-          UDOT_DOT: :tBDOT2,
-          UDOT_DOT_DOT: :tBDOT3,
-          UMINUS: :tUMINUS,
-          UMINUS_NUM: :tUNARY_NUM,
-          UPLUS: :tUPLUS,
-          USTAR: :tSTAR,
-          USTAR_STAR: :tDSTAR,
-          WORDS_SEP: :tSPACE
-        }
-
-        # These constants represent flags in our lex state. We really, really
-        # don't want to be using them and we really, really don't want to be
-        # exposing them as part of our public API. Unfortunately, we don't have
-        # another way of matching the exact tokens that the parser gem expects
-        # without them. We should find another way to do this, but in the
-        # meantime we'll hide them from the documentation and mark them as
-        # private constants.
-        EXPR_BEG = 0x1 # :nodoc:
-        EXPR_LABEL = 0x400 # :nodoc:
-
-        # It is used to determine whether `do` is of the token type `kDO` or `kDO_LAMBDA`.
-        #
-        # NOTE: In edge cases like `-> (foo = -> (bar) {}) do end`, please note that `kDO` is still returned
-        # instead of `kDO_LAMBDA`, which is expected: https://github.com/ruby/prism/pull/3046
-        LAMBDA_TOKEN_TYPES = Set.new([:kDO_LAMBDA, :tLAMBDA, :tLAMBEG])
-
-        # The `PARENTHESIS_LEFT` token in Prism is classified as either `tLPAREN` or `tLPAREN2` in the Parser gem.
-        # The following token types are listed as those classified as `tLPAREN`.
-        LPAREN_CONVERSION_TOKEN_TYPES = Set.new([
-          :kBREAK, :tCARET, :kCASE, :tDIVIDE, :kFOR, :kIF, :kNEXT, :kRETURN, :kUNTIL, :kWHILE, :tAMPER, :tANDOP, :tBANG, :tCOMMA, :tDOT2, :tDOT3,
-          :tEQL, :tLPAREN, :tLPAREN2, :tLPAREN_ARG, :tLSHFT, :tNL, :tOP_ASGN, :tOROP, :tPIPE, :tSEMI, :tSTRING_DBEG, :tUMINUS, :tUPLUS, :tLCURLY
-        ])
-
-        # Types of tokens that are allowed to continue a method call with comments in-between.
-        # For these, the parser gem doesn't emit a newline token after the last comment.
-        COMMENT_CONTINUATION_TYPES = Set.new([:COMMENT, :AMPERSAND_DOT, :DOT])
-        private_constant :COMMENT_CONTINUATION_TYPES
-
-        # Heredocs are complex and require us to keep track of a bit of info to refer to later
-        HeredocData = Struct.new(:identifier, :common_whitespace, keyword_init: true)
-
-        private_constant :TYPES, :EXPR_BEG, :EXPR_LABEL, :LAMBDA_TOKEN_TYPES, :LPAREN_CONVERSION_TOKEN_TYPES, :HeredocData
-
-        # The Parser::Source::Buffer that the tokens were lexed from.
-        attr_reader :source_buffer
-
-        # An array of tuples that contain prism tokens and their associated lex
-        # state when they were lexed.
-        attr_reader :lexed
-
-        # A hash that maps offsets in bytes to offsets in characters.
-        attr_reader :offset_cache
-
-        # Initialize the lexer with the given source buffer, prism tokens, and
-        # offset cache.
-        def initialize(source_buffer, lexed, offset_cache)
-          @source_buffer = source_buffer
-          @lexed = lexed
-          @offset_cache = offset_cache
-        end
-
-        Range = ::Parser::Source::Range # :nodoc:
-        private_constant :Range
-
-        # Convert the prism tokens into the expected format for the parser gem.
-        def to_a
-          tokens = []
-
-          index = 0
-          length = lexed.length
-
-          heredoc_stack = []
-          quote_stack = []
-
-          # The parser gem emits the newline tokens for comments out of order. This saves
-          # that token location to emit at a later time to properly line everything up.
-          # https://github.com/whitequark/parser/issues/1025
-          comment_newline_location = nil
-
-          while index < length
-            token, state = lexed[index]
-            index += 1
-            next if TYPES_ALWAYS_SKIP.include?(token.type)
-
-            type = TYPES.fetch(token.type)
-            value = token.value
-            location = range(token.location.start_offset, token.location.end_offset)
-
-            case type
-            when :kDO
-              nearest_lambda_token = tokens.reverse_each.find do |token|
-                LAMBDA_TOKEN_TYPES.include?(token.first)
-              end
-
-              if nearest_lambda_token&.first == :tLAMBDA
-                type = :kDO_LAMBDA
-              end
-            when :tCHARACTER
-              value.delete_prefix!("?")
-              # Character literals behave similar to double-quoted strings. We can use the same escaping mechanism.
-              value = unescape_string(value, "?")
-            when :tCOMMENT
-              if token.type == :EMBDOC_BEGIN
-
-                while !((next_token = lexed[index]&.first) && next_token.type == :EMBDOC_END) && (index < length - 1)
-                  value += next_token.value
-                  index += 1
-                end
-
-                value += next_token.value
-                location = range(token.location.start_offset, next_token.location.end_offset)
-                index += 1
-              else
-                is_at_eol = value.chomp!.nil?
-                location = range(token.location.start_offset, token.location.end_offset + (is_at_eol ? 0 : -1))
-
-                prev_token, _ = lexed[index - 2] if index - 2 >= 0
-                next_token, _ = lexed[index]
-
-                is_inline_comment = prev_token&.location&.start_line == token.location.start_line
-                if is_inline_comment && !is_at_eol && !COMMENT_CONTINUATION_TYPES.include?(next_token&.type)
-                  tokens << [:tCOMMENT, [value, location]]
-
-                  nl_location = range(token.location.end_offset - 1, token.location.end_offset)
-                  tokens << [:tNL, [nil, nl_location]]
-                  next
-                elsif is_inline_comment && next_token&.type == :COMMENT
-                  comment_newline_location = range(token.location.end_offset - 1, token.location.end_offset)
-                elsif comment_newline_location && !COMMENT_CONTINUATION_TYPES.include?(next_token&.type)
-                  tokens << [:tCOMMENT, [value, location]]
-                  tokens << [:tNL, [nil, comment_newline_location]]
-                  comment_newline_location = nil
-                  next
-                end
-              end
-            when :tNL
-              next_token, _ = lexed[index]
-              # Newlines after comments are emitted out of order.
-              if next_token&.type == :COMMENT
-                comment_newline_location = location
-                next
-              end
-
-              value = nil
-            when :tFLOAT
-              value = parse_float(value)
-            when :tIMAGINARY
-              value = parse_complex(value)
-            when :tINTEGER
-              if value.start_with?("+")
-                tokens << [:tUNARY_NUM, ["+", range(token.location.start_offset, token.location.start_offset + 1)]]
-                location = range(token.location.start_offset + 1, token.location.end_offset)
-              end
-
-              value = parse_integer(value)
-            when :tLABEL
-              value.chomp!(":")
-            when :tLABEL_END
-              value.chomp!(":")
-            when :tLCURLY
-              type = :tLBRACE if state == EXPR_BEG | EXPR_LABEL
-            when :tLPAREN2
-              type = :tLPAREN if tokens.empty? || LPAREN_CONVERSION_TOKEN_TYPES.include?(tokens.dig(-1, 0))
-            when :tNTH_REF
-              value = parse_integer(value.delete_prefix("$"))
-            when :tOP_ASGN
-              value.chomp!("=")
-            when :tRATIONAL
-              value = parse_rational(value)
-            when :tSPACE
-              location = range(token.location.start_offset, token.location.start_offset + percent_array_leading_whitespace(value))
-              value = nil
-            when :tSTRING_BEG
-              next_token, _ = lexed[index]
-              next_next_token, _ = lexed[index + 1]
-              basic_quotes = value == '"' || value == "'"
-
-              if basic_quotes && next_token&.type == :STRING_END
-                next_location = token.location.join(next_token.location)
-                type = :tSTRING
-                value = ""
-                location = range(next_location.start_offset, next_location.end_offset)
-                index += 1
-              elsif value.start_with?("'", '"', "%")
-                if next_token&.type == :STRING_CONTENT && next_next_token&.type == :STRING_END
-                  string_value = next_token.value
-                  if simplify_string?(string_value, value)
-                    next_location = token.location.join(next_next_token.location)
-                    if percent_array?(value)
-                      value = percent_array_unescape(string_value)
-                    else
-                      value = unescape_string(string_value, value)
-                    end
-                    type = :tSTRING
-                    location = range(next_location.start_offset, next_location.end_offset)
-                    index += 2
-                    tokens << [type, [value, location]]
-
-                    next
-                  end
-                end
-
-                quote_stack.push(value)
-              elsif token.type == :HEREDOC_START
-                quote = value[2] == "-" || value[2] == "~" ? value[3] : value[2]
-                heredoc_type = value[2] == "-" || value[2] == "~" ? value[2] : ""
-                heredoc = HeredocData.new(
-                  identifier: value.match(/<<[-~]?["'`]?(?<heredoc_identifier>.*?)["'`]?\z/)[:heredoc_identifier],
-                  common_whitespace: 0,
-                )
-
-                if quote == "`"
-                  type = :tXSTRING_BEG
-                end
-
-                # The parser gem trims whitespace from squiggly heredocs. We must record
-                # the most common whitespace to later remove.
-                if heredoc_type == "~" || heredoc_type == "`"
-                  heredoc.common_whitespace = calculate_heredoc_whitespace(index)
-                end
-
-                if quote == "'" || quote == '"' || quote == "`"
-                  value = "<<#{quote}"
-                else
-                  value = '<<"'
-                end
-
-                heredoc_stack.push(heredoc)
-                quote_stack.push(value)
-              end
-            when :tSTRING_CONTENT
-              is_percent_array = percent_array?(quote_stack.last)
-
-              if (lines = token.value.lines).one?
-                # Prism usually emits a single token for strings with line continuations.
-                # For squiggly heredocs they are not joined so we do that manually here.
-                current_string = +""
-                current_length = 0
-                start_offset = token.location.start_offset
-                while token.type == :STRING_CONTENT
-                  current_length += token.value.bytesize
-                  # Heredoc interpolation can have multiple STRING_CONTENT nodes on the same line.
-                  prev_token, _ = lexed[index - 2] if index - 2 >= 0
-                  is_first_token_on_line = prev_token && token.location.start_line != prev_token.location.start_line
-                  # The parser gem only removes indentation when the heredoc is not nested
-                  not_nested = heredoc_stack.size == 1
-                  if is_percent_array
-                    value = percent_array_unescape(token.value)
-                  elsif is_first_token_on_line && not_nested && (current_heredoc = heredoc_stack.last).common_whitespace > 0
-                    value = trim_heredoc_whitespace(token.value, current_heredoc)
-                  end
-
-                  current_string << unescape_string(value, quote_stack.last)
-                  relevant_backslash_count = if quote_stack.last.start_with?("%W", "%I")
-                                               0 # the last backslash escapes the newline
-                                             else
-                                               token.value[/(\\{1,})\n/, 1]&.length || 0
-                                             end
-                  if relevant_backslash_count.even? || !interpolation?(quote_stack.last)
-                    tokens << [:tSTRING_CONTENT, [current_string, range(start_offset, start_offset + current_length)]]
-                    break
-                  end
-                  token, _ = lexed[index]
-                  index += 1
-                end
-              else
-                # When the parser gem encounters a line continuation inside of a multiline string,
-                # it emits a single string node. The backslash (and remaining newline) is removed.
-                current_line = +""
-                adjustment = 0
-                start_offset = token.location.start_offset
-                emit = false
-
-                lines.each.with_index do |line, index|
-                  chomped_line = line.chomp
-                  backslash_count = chomped_line[/\\{1,}\z/]&.length || 0
-                  is_interpolation = interpolation?(quote_stack.last)
-
-                  if backslash_count.odd? && (is_interpolation || is_percent_array)
-                    if is_percent_array
-                      current_line << percent_array_unescape(line)
-                      adjustment += 1
-                    else
-                      chomped_line.delete_suffix!("\\")
-                      current_line << chomped_line
-                      adjustment += 2
-                    end
-                    # If the string ends with a line continuation emit the remainder
-                    emit = index == lines.count - 1
-                  else
-                    current_line << line
-                    emit = true
-                  end
-
-                  if emit
-                    end_offset = start_offset + current_line.bytesize + adjustment
-                    tokens << [:tSTRING_CONTENT, [unescape_string(current_line, quote_stack.last), range(start_offset, end_offset)]]
-                    start_offset = end_offset
-                    current_line = +""
-                    adjustment = 0
-                  end
-                end
-              end
-              next
-            when :tSTRING_DVAR
-              value = nil
-            when :tSTRING_END
-              if token.type == :HEREDOC_END && value.end_with?("\n")
-                newline_length = value.end_with?("\r\n") ? 2 : 1
-                value = heredoc_stack.pop.identifier
-                location = range(token.location.start_offset, token.location.end_offset - newline_length)
-              elsif token.type == :REGEXP_END
-                value = value[0]
-                location = range(token.location.start_offset, token.location.start_offset + 1)
-              end
-
-              if percent_array?(quote_stack.pop)
-                prev_token, _ = lexed[index - 2] if index - 2 >= 0
-                empty = %i[PERCENT_LOWER_I PERCENT_LOWER_W PERCENT_UPPER_I PERCENT_UPPER_W].include?(prev_token&.type)
-                ends_with_whitespace = prev_token&.type == :WORDS_SEP
-                # parser always emits a space token after content in a percent array, even if no actual whitespace is present.
-                if !empty && !ends_with_whitespace
-                  tokens << [:tSPACE, [nil, range(token.location.start_offset, token.location.start_offset)]]
-                end
-              end
-            when :tSYMBEG
-              if (next_token = lexed[index]&.first) && next_token.type != :STRING_CONTENT && next_token.type != :EMBEXPR_BEGIN && next_token.type != :EMBVAR && next_token.type != :STRING_END
-                next_location = token.location.join(next_token.location)
-                type = :tSYMBOL
-                value = next_token.value
-                value = { "~@" => "~", "!@" => "!" }.fetch(value, value)
-                location = range(next_location.start_offset, next_location.end_offset)
-                index += 1
-              else
-                quote_stack.push(value)
-              end
-            when :tFID
-              if !tokens.empty? && tokens.dig(-1, 0) == :kDEF
-                type = :tIDENTIFIER
-              end
-            when :tXSTRING_BEG
-              if (next_token = lexed[index]&.first) && !%i[STRING_CONTENT STRING_END EMBEXPR_BEGIN].include?(next_token.type)
-                # self.`()
-                type = :tBACK_REF2
-              end
-              quote_stack.push(value)
-            when :tSYMBOLS_BEG, :tQSYMBOLS_BEG, :tWORDS_BEG, :tQWORDS_BEG
-              if (next_token = lexed[index]&.first) && next_token.type == :WORDS_SEP
-                index += 1
-              end
-
-              quote_stack.push(value)
-            when :tREGEXP_BEG
-              quote_stack.push(value)
-            end
-
-            tokens << [type, [value, location]]
-
-            if token.type == :REGEXP_END
-              tokens << [:tREGEXP_OPT, [token.value[1..], range(token.location.start_offset + 1, token.location.end_offset)]]
-            end
-          end
-
-          tokens
-        end
-
-        private
-
-        # Creates a new parser range, taking prisms byte offsets into account
-        def range(start_offset, end_offset)
-          Range.new(source_buffer, offset_cache[start_offset], offset_cache[end_offset])
-        end
-
-        # Parse an integer from the string representation.
-        def parse_integer(value)
-          Integer(value)
-        rescue ArgumentError
-          0
-        end
-
-        # Parse a float from the string representation.
-        def parse_float(value)
-          Float(value)
-        rescue ArgumentError
-          0.0
-        end
-
-        # Parse a complex from the string representation.
-        def parse_complex(value)
-          value.chomp!("i")
-
-          if value.end_with?("r")
-            Complex(0, parse_rational(value))
-          elsif value.start_with?(/0[BbOoDdXx]/)
-            Complex(0, parse_integer(value))
-          else
-            Complex(0, value)
-          end
-        rescue ArgumentError
-          0i
-        end
-
-        # Parse a rational from the string representation.
-        def parse_rational(value)
-          value.chomp!("r")
-
-          if value.start_with?(/0[BbOoDdXx]/)
-            Rational(parse_integer(value))
-          else
-            Rational(value)
-          end
-        rescue ArgumentError
-          0r
-        end
-
-        # Wonky heredoc tab/spaces rules.
-        # https://github.com/ruby/prism/blob/v1.3.0/src/prism.c#L10548-L10558
-        def calculate_heredoc_whitespace(heredoc_token_index)
-          next_token_index = heredoc_token_index
-          nesting_level = 0
-          previous_line = -1
-          result = Float::MAX
-
-          while (next_token = lexed[next_token_index]&.first)
-            next_token_index += 1
-            next_next_token, _ = lexed[next_token_index]
-            first_token_on_line = next_token.location.start_column == 0
-
-            # String content inside nested heredocs and interpolation is ignored
-            if next_token.type == :HEREDOC_START || next_token.type == :EMBEXPR_BEGIN
-              # When interpolation is the first token of a line there is no string
-              # content to check against. There will be no common whitespace.
-              if nesting_level == 0 && first_token_on_line
-                result = 0
-              end
-              nesting_level += 1
-            elsif next_token.type == :HEREDOC_END || next_token.type == :EMBEXPR_END
-              nesting_level -= 1
-              # When we encountered the matching heredoc end, we can exit
-              break if nesting_level == -1
-            elsif next_token.type == :STRING_CONTENT && nesting_level == 0 && first_token_on_line
-              common_whitespace = 0
-              next_token.value[/^\s*/].each_char do |char|
-                if char == "\t"
-                  common_whitespace = (common_whitespace / 8 + 1) * 8;
-                else
-                  common_whitespace += 1
-                end
-              end
-
-              is_first_token_on_line = next_token.location.start_line != previous_line
-              # Whitespace is significant if followed by interpolation
-              whitespace_only = common_whitespace == next_token.value.length && next_next_token&.location&.start_line != next_token.location.start_line
-              if is_first_token_on_line && !whitespace_only && common_whitespace < result
-                result = common_whitespace
-                previous_line = next_token.location.start_line
-              end
-            end
-          end
-          result
-        end
-
-        # Wonky heredoc tab/spaces rules.
-        # https://github.com/ruby/prism/blob/v1.3.0/src/prism.c#L16528-L16545
-        def trim_heredoc_whitespace(string, heredoc)
-          trimmed_whitespace = 0
-          trimmed_characters = 0
-          while (string[trimmed_characters] == "\t" || string[trimmed_characters] == " ") && trimmed_whitespace < heredoc.common_whitespace
-            if string[trimmed_characters] == "\t"
-              trimmed_whitespace = (trimmed_whitespace / 8 + 1) * 8;
-              break if trimmed_whitespace > heredoc.common_whitespace
-            else
-              trimmed_whitespace += 1
-            end
-            trimmed_characters += 1
-          end
-
-          string[trimmed_characters..]
-        end
-
-        # Escape sequences that have special and should appear unescaped in the resulting string.
-        ESCAPES = {
-          "a" => "\a", "b" => "\b", "e" => "\e", "f" => "\f",
-          "n" => "\n", "r" => "\r", "s" => "\s", "t" => "\t",
-          "v" => "\v", "\\" => "\\"
-        }.freeze
-        private_constant :ESCAPES
-
-        # When one of these delimiters is encountered, then the other
-        # one is allowed to be escaped as well.
-        DELIMITER_SYMETRY = { "[" => "]", "(" => ")", "{" => "}", "<" => ">" }.freeze
-        private_constant :DELIMITER_SYMETRY
-
-
-        # https://github.com/whitequark/parser/blob/v3.3.6.0/lib/parser/lexer-strings.rl#L14
-        REGEXP_META_CHARACTERS = ["\\", "$", "(", ")", "*", "+", ".", "<", ">", "?", "[", "]", "^", "{", "|", "}"]
-        private_constant :REGEXP_META_CHARACTERS
-
-        # Apply Ruby string escaping rules
-        def unescape_string(string, quote)
-          # In single-quoted heredocs, everything is taken literally.
-          return string if quote == "<<'"
-
-          # OPTIMIZATION: Assume that few strings need escaping to speed up the common case.
-          return string unless string.include?("\\")
-
-          # Enclosing character for the string. `"` for `"foo"`, `{` for `%w{foo}`, etc.
-          delimiter = quote[-1]
-
-          if regexp?(quote)
-            # Should be escaped handled to single-quoted heredocs. The only character that is
-            # allowed to be escaped is the delimiter, except when that also has special meaning
-            # in the regexp. Since all the symetry delimiters have special meaning, they don't need
-            # to be considered separately.
-            if REGEXP_META_CHARACTERS.include?(delimiter)
-              string
-            else
-              # There can never be an even amount of backslashes. It would be a syntax error.
-              string.gsub(/\\(#{Regexp.escape(delimiter)})/, '\1')
-            end
-          elsif interpolation?(quote)
-            # Appending individual escape sequences may force the string out of its intended
-            # encoding. Start out with binary and force it back later.
-            result = "".b
-
-            scanner = StringScanner.new(string)
-            while (skipped = scanner.skip_until(/\\/))
-              # Append what was just skipped over, excluding the found backslash.
-              result.append_as_bytes(string.byteslice(scanner.pos - skipped, skipped - 1))
-              escape_read(result, scanner, false, false)
-            end
-
-            # Add remaining chars
-            result.append_as_bytes(string.byteslice(scanner.pos..))
-            result.force_encoding(source_buffer.source.encoding)
-          else
-            delimiters = Regexp.escape("#{delimiter}#{DELIMITER_SYMETRY[delimiter]}")
-            string.gsub(/\\([\\#{delimiters}])/, '\1')
-          end
-        end
-
-        # Certain strings are merged into a single string token.
-        def simplify_string?(value, quote)
-          case quote
-          when "'"
-            # Only simplify 'foo'
-            !value.include?("\n")
-          when '"'
-            # Simplify when every line ends with a line continuation, or it is the last line
-            value.lines.all? do |line|
-              !line.end_with?("\n") || line[/(\\*)$/, 1]&.length&.odd?
-            end
-          else
-            # %q and similar are never simplified
-            false
-          end
-        end
-
-        # Escape a byte value, given the control and meta flags.
-        def escape_build(value, control, meta)
-          value &= 0x9f if control
-          value |= 0x80 if meta
-          value
-        end
-
-        # Read an escape out of the string scanner, given the control and meta
-        # flags, and push the unescaped value into the result.
-        def escape_read(result, scanner, control, meta)
-          if scanner.skip("\n")
-            # Line continuation
-          elsif (value = ESCAPES[scanner.peek(1)])
-            # Simple single-character escape sequences like \n
-            result.append_as_bytes(value)
-            scanner.pos += 1
-          elsif (value = scanner.scan(/[0-7]{1,3}/))
-            # \nnn
-            result.append_as_bytes(escape_build(value.to_i(8), control, meta))
-          elsif (value = scanner.scan(/x[0-9a-fA-F]{1,2}/))
-            # \xnn
-            result.append_as_bytes(escape_build(value[1..].to_i(16), control, meta))
-          elsif (value = scanner.scan(/u[0-9a-fA-F]{4}/))
-            # \unnnn
-            result.append_as_bytes(value[1..].hex.chr(Encoding::UTF_8))
-          elsif scanner.skip("u{}")
-            # https://github.com/whitequark/parser/issues/856
-          elsif (value = scanner.scan(/u{.*?}/))
-            # \u{nnnn ...}
-            value[2..-2].split.each do |unicode|
-              result.append_as_bytes(unicode.hex.chr(Encoding::UTF_8))
-            end
-          elsif (value = scanner.scan(/c\\?(?=[[:print:]])|C-\\?(?=[[:print:]])/))
-            # \cx or \C-x where x is an ASCII printable character
-            escape_read(result, scanner, true, meta)
-          elsif (value = scanner.scan(/M-\\?(?=[[:print:]])/))
-            # \M-x where x is an ASCII printable character
-            escape_read(result, scanner, control, true)
-          elsif (byte = scanner.scan_byte)
-            # Something else after an escape.
-            if control && byte == 0x3f # ASCII '?'
-              result.append_as_bytes(escape_build(0x7f, false, meta))
-            else
-              result.append_as_bytes(escape_build(byte, control, meta))
-            end
-          end
-        end
-
-        # In a percent array, certain whitespace can be preceeded with a backslash,
-        # causing the following characters to be part of the previous element.
-        def percent_array_unescape(string)
-          string.gsub(/(\\)+[ \f\n\r\t\v]/) do |full_match|
-            full_match.delete_prefix!("\\") if Regexp.last_match[1].length.odd?
-            full_match
-          end
-        end
-
-        # For %-arrays whitespace, the parser gem only considers whitespace before the newline.
-        def percent_array_leading_whitespace(string)
-          return 1 if string.start_with?("\n")
-
-          leading_whitespace = 0
-          string.each_char do |c|
-            break if c == "\n"
-            leading_whitespace += 1
-          end
-          leading_whitespace
-        end
-
-        # Determine if characters preceeded by a backslash should be escaped or not
-        def interpolation?(quote)
-          !quote.end_with?("'") && !quote.start_with?("%q", "%w", "%i", "%s")
-        end
-
-        # Regexp allow interpolation but are handled differently during unescaping
-        def regexp?(quote)
-          quote == "/" || quote.start_with?("%r")
-        end
-
-        # Determine if the string is part of a %-style array.
-        def percent_array?(quote)
-          quote.start_with?("%w", "%W", "%i", "%I")
-        end
-      end
-    end
-  end
-end