prism 0.19.0 → 0.24.0

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

@@ -0,0 +1,335 @@
+# frozen_string_literal: true
+
+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
+        # The direct translating of types between the two lexers.
+        TYPES = {
+          # These tokens should never appear in the output of the lexer.
+          EOF: nil,
+          MISSING: nil,
+          NOT_PROVIDED: nil,
+          IGNORED_NEWLINE: nil,
+          EMBDOC_END: nil,
+          EMBDOC_LINE: nil,
+          __END__: 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: :tLPAREN,
+          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: :tDOT2,
+          UDOT_DOT_DOT: :tBDOT3,
+          UMINUS: :tUMINUS,
+          UMINUS_NUM: :tUNARY_NUM,
+          UPLUS: :tUPLUS,
+          USTAR: :tSTAR,
+          USTAR_STAR: :tPOW,
+          WORDS_SEP: :tSPACE
+        }
+
+        private_constant :TYPES
+
+        # The Parser::Source::Buffer that the tokens were lexed from.
+        attr_reader :source_buffer
+
+        # An array of prism tokens that we 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
+
+          while index < lexed.length
+            token, = lexed[index]
+            index += 1
+            next if token.type == :IGNORED_NEWLINE || token.type == :EOF
+
+            type = TYPES.fetch(token.type)
+            value = token.value
+            location = Range.new(source_buffer, offset_cache[token.location.start_offset], offset_cache[token.location.end_offset])
+
+            case type
+            when :tCHARACTER
+              value.delete_prefix!("?")
+            when :tCOMMENT
+              if token.type == :EMBDOC_BEGIN
+                until (next_token = lexed[index]) && next_token.type == :EMBDOC_END
+                  value += next_token.value
+                  index += 1
+                end
+
+                value += next_token.value
+                location = Range.new(source_buffer, offset_cache[token.location.start_offset], offset_cache[lexed[index].location.end_offset])
+                index += 1
+              else
+                value.chomp!
+                location = Range.new(source_buffer, offset_cache[token.location.start_offset], offset_cache[token.location.end_offset - 1])
+              end
+            when :tNL
+              value = nil
+            when :tFLOAT
+              value = Float(value)
+            when :tIMAGINARY
+              value = parse_complex(value)
+            when :tINTEGER
+              if value.start_with?("+")
+                tokens << [:tUNARY_NUM, ["+", Range.new(source_buffer, offset_cache[token.location.start_offset], offset_cache[token.location.start_offset + 1])]]
+                location = Range.new(source_buffer, offset_cache[token.location.start_offset + 1], offset_cache[token.location.end_offset])
+              end
+
+              value = Integer(value)
+            when :tLABEL
+              value.chomp!(":")
+            when :tLABEL_END
+              value.chomp!(":")
+            when :tNTH_REF
+              value = Integer(value.delete_prefix("$"))
+            when :tOP_ASGN
+              value.chomp!("=")
+            when :tRATIONAL
+              value = parse_rational(value)
+            when :tSPACE
+              value = nil
+            when :tSTRING_BEG
+              if ["\"", "'"].include?(value) && (next_token = lexed[index]) && next_token.type == :STRING_END
+                next_location = token.location.join(next_token.location)
+                type = :tSTRING
+                value = ""
+                location = Range.new(source_buffer, offset_cache[next_location.start_offset], offset_cache[next_location.end_offset])
+                index += 1
+              elsif ["\"", "'"].include?(value) && (next_token = lexed[index]) && next_token.type == :STRING_CONTENT && (next_next_token = lexed[index + 1]) && next_next_token.type == :STRING_END
+                next_location = token.location.join(next_next_token.location)
+                type = :tSTRING
+                value = next_token.value
+                location = Range.new(source_buffer, offset_cache[next_location.start_offset], offset_cache[next_location.end_offset])
+                index += 2
+              elsif value.start_with?("<<")
+                quote = value[2] == "-" || value[2] == "~" ? value[3] : value[2]
+                value = "<<#{quote == "'" || quote == "\"" ? quote : "\""}"
+              end
+            when :tSTRING_DVAR
+              value = nil
+            when :tSTRING_END
+              if token.type == :REGEXP_END
+                value = value[0]
+                location = Range.new(source_buffer, offset_cache[token.location.start_offset], offset_cache[token.location.start_offset + 1])
+              end
+            when :tSYMBEG
+              if (next_token = lexed[index]) && next_token.type != :STRING_CONTENT && next_token.type != :EMBEXPR_BEGIN && next_token.type != :EMBVAR
+                next_location = token.location.join(next_token.location)
+                type = :tSYMBOL
+                value = next_token.value
+                value = { "~@" => "~", "!@" => "!" }.fetch(value, value)
+                location = Range.new(source_buffer, offset_cache[next_location.start_offset], offset_cache[next_location.end_offset])
+                index += 1
+              end
+            when :tFID
+              if tokens[-1][0] == :kDEF
+                type = :tIDENTIFIER
+              end
+            end
+
+            tokens << [type, [value, location]]
+
+            if token.type == :REGEXP_END
+              tokens << [:tREGEXP_OPT, [token.value[1..], Range.new(source_buffer, offset_cache[token.location.start_offset + 1], offset_cache[token.location.end_offset])]]
+            end
+          end
+
+          tokens
+        end
+
+        private
+
+        # 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, Integer(value))
+          else
+            Complex(0, value)
+          end
+        end
+
+        # Parse a rational from the string representation.
+        def parse_rational(value)
+          value.chomp!("r")
+
+          if value.start_with?(/0[BbOoDdXx]/)
+            Rational(Integer(value))
+          else
+            Rational(value)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "parser"
+require "rubocop"
+
+require "prism"
+require "prism/translation/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
+        # 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
+            require "prism/translation/parser33"
+            Prism::Translation::Parser33
+          elsif ruby_version == Prism::Translation::Parser::VERSION_3_4
+            require "prism/translation/parser34"
+            Prism::Translation::Parser34
+          else
+            super
+          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/lib/prism/translation/parser.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+require "parser"
+
+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.
+    class Parser < ::Parser::Base
+      # 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 Diagnostic < ::Parser::Diagnostic
+        # The message generated by prism.
+        attr_reader :message
+
+        # Initialize a new diagnostic with the given message and location.
+        def initialize(message, location)
+          @message = message
+          super(:error, :prism_error, {}, location, [])
+        end
+      end
+
+      Racc_debug_parser = false # :nodoc:
+
+      def version # :nodoc:
+        34
+      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(Prism.parse(source, filepath: source_buffer.name, version: convert_for_prism(version)), 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(Prism.parse(source, filepath: source_buffer.name, version: convert_for_prism(version)), 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(Prism.parse_lex(source, filepath: source_buffer.name, version: convert_for_prism(version)), 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
+
+      # 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)
+
+          location = build_range(error.location, offset_cache)
+          diagnostics.process(Diagnostic.new(error.message, location))
+        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.map(&:first), 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
+
+      # Converts the version format handled by Parser to the format handled by Prism.
+      def convert_for_prism(version)
+        case version
+        when 33
+          "3.3.0"
+        when 34
+          "3.4.0"
+        else
+          "latest"
+        end
+      end
+
+      require_relative "parser/compiler"
+      require_relative "parser/lexer"
+
+      private_constant :Compiler
+      private_constant :Lexer
+    end
+  end
+end

data/lib/prism/translation/parser33.rb

@@ -0,0 +1,12 @@
+require_relative "parser"
+
+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

data/lib/prism/translation/parser34.rb

@@ -0,0 +1,12 @@
+require_relative "parser"
+
+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