SWAMPy

✎ CARVE FLESH

EDITING: base.rb

# frozen_string_literal: true

module Parser

##
  # Base class for version-specific parsers.
  #
  # @api public
  #
  # @!attribute [r] diagnostics
  #  @return [Parser::Diagnostic::Engine]
  #
  # @!attribute [r] static_env
  #  @return [Parser::StaticEnvironment]
  #
  class Base < Racc::Parser
    ##
    # Parses a string of Ruby code and returns the AST. If the source
    # cannot be parsed, {SyntaxError} is raised and a diagnostic is
    # printed to `stderr`.
    #
    # @example
    #  Parser::Base.parse('puts "hello"')
    #
    # @param [String] string The block of code to parse.
    # @param [String] file The name of the file the code originated from.
    # @param [Numeric] line The initial line number.
    # @return [Parser::AST::Node]
    #
    def self.parse(string, file='(string)', line=1)
      parser = default_parser
      source_buffer = setup_source_buffer(file, line, string, parser.default_encoding)
      parser.parse(source_buffer)
    end

##
    # Parses a string of Ruby code and returns the AST and comments. If the
    # source cannot be parsed, {SyntaxError} is raised and a diagnostic is
    # printed to `stderr`.
    #
    # @example
    #  Parser::Base.parse_with_comments('puts "hello"')
    #
    # @param [String] string The block of code to parse.
    # @param [String] file The name of the file the code originated from.
    # @param [Numeric] line The initial line number.
    # @return [Array]
    #
    def self.parse_with_comments(string, file='(string)', line=1)
      parser = default_parser
      source_buffer = setup_source_buffer(file, line, string, parser.default_encoding)
      parser.parse_with_comments(source_buffer)
    end

##
    # Parses Ruby source code by reading it from a file. If the source
    # cannot be parsed, {SyntaxError} is raised and a diagnostic is
    # printed to `stderr`.
    #
    # @param [String] filename Path to the file to parse.
    # @return [Parser::AST::Node]
    # @see #parse
    #
    def self.parse_file(filename)
      parse(File.read(filename), filename)
    end

##
    # Parses Ruby source code by reading it from a file and returns the AST and
    # comments. If the source cannot be parsed, {SyntaxError} is raised and a
    # diagnostic is printed to `stderr`.
    #
    # @param [String] filename Path to the file to parse.
    # @return [Array]
    # @see #parse
    #
    def self.parse_file_with_comments(filename)
      parse_with_comments(File.read(filename), filename)
    end

##
    # @return [Parser::Base] parser with the default options set.
    #
    def self.default_parser
      parser = new

parser.diagnostics.all_errors_are_fatal = true
      parser.diagnostics.ignore_warnings      = true

parser.diagnostics.consumer = lambda do |diagnostic|
        $stderr.puts(diagnostic.render)
      end

parser
    end

def self.setup_source_buffer(file, line, string, encoding)
      string = string.dup.force_encoding(encoding)

source_buffer = Source::Buffer.new(file, line)

if name == 'Parser::Ruby18'
        source_buffer.raw_source = string
      else
        source_buffer.source     = string
      end

source_buffer
    end
    private_class_method :setup_source_buffer

attr_reader :lexer
    attr_reader :diagnostics
    attr_reader :builder
    attr_reader :static_env
    attr_reader :source_buffer
    attr_reader :context
    attr_reader :max_numparam_stack
    attr_reader :current_arg_stack
    attr_reader :pattern_variables
    attr_reader :pattern_hash_keys

##
    # @param [Parser::Builders::Default] builder The AST builder to use.
    #
    def initialize(builder=Parser::Builders::Default.new)
      @diagnostics = Diagnostic::Engine.new

@static_env  = StaticEnvironment.new

# Stack that holds current parsing context
      @context = Context.new

# Maximum numbered parameters stack
      @max_numparam_stack = MaxNumparamStack.new

# Current argument names stack
      @current_arg_stack = CurrentArgStack.new

# Stack of set of variables used in the current pattern
      @pattern_variables = VariablesStack.new

# Stack of set of keys used in the current hash in pattern matchinig
      @pattern_hash_keys = VariablesStack.new

@lexer = Lexer.new(version)
      @lexer.diagnostics = @diagnostics
      @lexer.static_env  = @static_env
      @lexer.context     = @context

@builder = builder
      @builder.parser = self

# Last emitted token
      @last_token = nil

if self.class::Racc_debug_parser && ENV['RACC_DEBUG']
        @yydebug = true
      end

reset
    end

##
    # Resets the state of the parser.
    #
    def reset
      @source_buffer = nil

@lexer.reset
      @static_env.reset
      @context.reset
      @current_arg_stack.reset
      @pattern_variables.reset
      @pattern_hash_keys.reset

self
    end

##
    # Parses a source buffer and returns the AST, or `nil` in case of a non fatal error.
    #
    # @param [Parser::Source::Buffer] source_buffer The source buffer to parse.
    # @return [Parser::AST::Node, nil]
    #
    def parse(source_buffer)
      @lexer.source_buffer = source_buffer
      @source_buffer       = source_buffer

do_parse || nil # Force `false` to `nil`, see https://github.com/ruby/racc/pull/136
    ensure
      # Don't keep references to the source file.
      @source_buffer       = nil
      @lexer.source_buffer = nil
    end

##
    # Parses a source buffer and returns the AST and the source code comments.
    #
    # @see #parse
    # @see Parser::Source::Comment#associate
    # @return [Array]
    #
    def parse_with_comments(source_buffer)
      @lexer.comments = []

[ parse(source_buffer), @lexer.comments ]
    ensure
      @lexer.comments = nil
    end

##
    # Parses a source buffer and returns the AST, the source code comments,
    # and the tokens emitted by the lexer. In case of a fatal error, a {SyntaxError}
    # is raised, unless `recover` is true. In case of an error
    # (non-fatal or recovered), `nil` is returned instead of the AST, and
    # comments as well as tokens are only returned up to the location of
    # the error.
    #
    # Currently, token stream format returned by #tokenize is not documented,
    # but is considered part of a public API and only changed according
    # to Semantic Versioning.
    #
    # However, note that the exact token composition of various constructs
    # might vary. For example, a string `"foo"` is represented equally well
    # by `:tSTRING_BEG " :tSTRING_CONTENT foo :tSTRING_END "` and
    # `:tSTRING "foo"`; such details must not be relied upon.
    #
    # @param [Parser::Source::Buffer] source_buffer
    # @param [Boolean] recover If true, recover from syntax errors. False by default.
    # @return [Array]
    #
    def tokenize(source_buffer, recover=false)
      @lexer.tokens = []
      @lexer.comments = []

begin
        ast = parse(source_buffer)
      rescue Parser::SyntaxError
        raise if !recover
      end

[ ast, @lexer.comments, @lexer.tokens ]
    ensure
      @lexer.tokens = nil
      @lexer.comments = nil
    end

private

def next_token
      token = @lexer.advance
      @last_token = token
      token
    end

def check_kwarg_name(name_t)
      case name_t[0]
      when /^[a-z_]/
        # OK
      when /^[A-Z]/
        diagnostic :error, :argument_const, nil, name_t
      end
    end

def diagnostic(level, reason, arguments, location_t, highlights_ts=[])
      _, location = location_t

highlights = highlights_ts.map do |token|
        _, range = token
        range
      end

@diagnostics.process(
          Diagnostic.new(level, reason, arguments, location, highlights))

if level == :error
        yyerror
      end
    end

def on_error(error_token_id, error_value, value_stack)
      token_name = token_to_str(error_token_id)
      _, location = error_value

@diagnostics.process(Diagnostic.new(
          :error, :unexpected_token, { :token => token_name }, location))
    end
  end

end

CANCEL

Name	Type	Size	Modified	Actions
↩ ..	DIR	—	—
📁 ast/	DIR	—	2023-09-24 03:48
📁 builders/	DIR	—	2023-09-24 03:48
📁 diagnostic/	DIR	—	2023-09-24 03:48
📁 lexer/	DIR	—	2023-09-24 03:48
📁 runner/	DIR	—	2023-09-24 03:48
📁 source/	DIR	—	2023-09-24 03:48
📄 all.rb	RB	367 B	2023-09-24 03:48	EDIT
📄 base.rb	RB	8 KB	2023-09-24 03:48	EDIT
📄 clobbering_error.rb	RB	331 B	2023-09-24 03:48	EDIT
📄 color.rb	RB	627 B	2023-09-24 03:48	EDIT
📄 context.rb	RB	1.2 KB	2023-09-24 03:48	EDIT
📄 current.rb	RB	3.1 KB	2023-09-24 03:48	EDIT
📄 current_arg_stack.rb	RB	717 B	2023-09-24 03:48	EDIT
📄 deprecation.rb	RB	250 B	2023-09-24 03:48	EDIT
📄 diagnostic.rb	RB	4.2 KB	2023-09-24 03:48	EDIT
📄 lexer-F0.rb	RB	409.6 KB	2023-09-24 03:48	EDIT
📄 lexer-F1.rb	RB	441.3 KB	2023-09-24 03:48	EDIT
📄 lexer-strings.rb	RB	167.3 KB	2023-09-24 03:48	EDIT
📄 macruby.rb	RB	464.8 KB	2023-09-24 03:48	EDIT
📄 max_numparam_stack.rb	RB	781 B	2023-09-24 03:48	EDIT
📄 messages.rb	RB	6.7 KB	2023-09-24 03:48	EDIT
📄 meta.rb	RB	1.6 KB	2023-09-24 03:48	EDIT
📄 rewriter.rb	RB	2.5 KB	2023-09-24 03:48	EDIT
📄 ruby18.rb	RB	461.9 KB	2023-09-24 03:48	EDIT
📄 ruby19.rb	RB	461.4 KB	2023-09-24 03:48	EDIT
📄 ruby20.rb	RB	493.4 KB	2023-09-24 03:48	EDIT
📄 ruby21.rb	RB	489.4 KB	2023-09-24 03:48	EDIT
📄 ruby22.rb	RB	495.5 KB	2023-09-24 03:48	EDIT
📄 ruby23.rb	RB	496.3 KB	2023-09-24 03:48	EDIT
📄 ruby24.rb	RB	503.6 KB	2023-09-24 03:48	EDIT
📄 ruby25.rb	RB	498.6 KB	2023-09-24 03:48	EDIT
📄 ruby26.rb	RB	496 KB	2023-09-24 03:48	EDIT
📄 ruby27.rb	RB	566.7 KB	2023-09-24 03:48	EDIT
📄 ruby28.rb	RB	306.8 KB	2023-09-24 03:48	EDIT
📄 ruby30.rb	RB	582.8 KB	2023-09-24 03:48	EDIT
📄 ruby31.rb	RB	608 KB	2023-09-24 03:48	EDIT
📄 ruby32.rb	RB	607.6 KB	2023-09-24 03:48	EDIT
📄 ruby33.rb	RB	607.6 KB	2023-09-24 03:48	EDIT
📄 rubymotion.rb	RB	458.1 KB	2023-09-24 03:48	EDIT
📄 runner.rb	RB	7.1 KB	2023-09-24 03:48	EDIT
📄 static_environment.rb	RB	1.4 KB	2023-09-24 03:48	EDIT
📄 syntax_error.rb	RB	443 B	2023-09-24 03:48	EDIT
📄 tree_rewriter.rb	RB	3.5 KB	2023-09-24 03:48	EDIT
📄 variables_stack.rb	RB	443 B	2023-09-24 03:48	EDIT
📄 version.rb	RB	71 B	2023-09-24 03:48	EDIT