parser 2.6.5.0 → 2.7.2.0

data/test/bug_163/fixtures/input.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-if(true)
-  puts "Hello, world!"
-end

data/test/bug_163/fixtures/output.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-if true
-  puts "Hello, world!"
-end

data/test/bug_163/rewriter.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-class Rewriter < Parser::Rewriter
-  def on_if(node)
-    # Crude, totally-not-usable-in-the-real-world code to remove optional
-    # parens from control keywords.
-    #
-    # In a perfect test scenario we'd simply make this a no-op, to demonstrate
-    # that the bug happens when any rewriter is loaded regardless of whether it
-    # actually changes anything but that makes assertions much harder to get
-    # right.  It's much easier to just show that the file did, or did not
-    # get changed.
-    if node.children[0].type == :begin
-      replace node.children[0].loc.begin, ' '
-      remove node.children[0].loc.end
-    end
-
-    super
-  end
-end

data/test/helper.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-require 'tempfile'
-require 'minitest/test'
-
-require 'simplecov'
-
-if ENV.include?('COVERAGE') && SimpleCov.usable?
-  require_relative 'racc_coverage_helper'
-
-  RaccCoverage.start(
-    %w(
-      ruby18.y
-      ruby19.y
-      ruby20.y
-      ruby21.y
-      ruby22.y
-      ruby23.y
-      ruby24.y
-      ruby25.y
-      ruby26.y
-    ),
-    File.expand_path('../../lib/parser', __FILE__))
-
-  # Report results faster.
-  at_exit { RaccCoverage.stop }
-
-  SimpleCov.start do
-    self.formatter = SimpleCov::Formatter::MultiFormatter[
-      SimpleCov::Formatter::HTMLFormatter,
-    ]
-
-    add_group 'Grammars' do |source_file|
-      source_file.filename =~ %r{\.y$}
-    end
-
-    # Exclude the testsuite itself.
-    add_filter '/test/'
-
-    # Exclude generated files.
-    add_filter do |source_file|
-      source_file.filename =~ %r{/lib/parser/(lexer|ruby\d+|macruby|rubymotion)\.rb$}
-    end
-  end
-end
-
-# minitest/autorun must go after SimpleCov to preserve
-# correct order of at_exit hooks.
-require 'minitest/autorun'
-
-$LOAD_PATH.unshift(File.expand_path('../../lib', __FILE__))
-require 'parser'
-
-class Parser::AST::Node
-  def initialize(type, *)
-    raise "Type #{type} missing from Parser::Meta::NODE_TYPES" unless Parser::Meta::NODE_TYPES.include?(type)
-    super
-  end
-end

data/test/parse_helper.rb

@@ -1,316 +0,0 @@
-# frozen_string_literal: true
-
-module ParseHelper
-  include AST::Sexp
-
-  require 'parser/all'
-  require 'parser/macruby'
-  require 'parser/rubymotion'
-
-  ALL_VERSIONS = %w(1.8 1.9 2.0 2.1 2.2 2.3 2.4 2.5 2.6 2.7 mac ios)
-
-  def setup
-    @diagnostics = []
-
-    super if defined?(super)
-  end
-
-  def parser_for_ruby_version(version)
-    case version
-    when '1.8' then parser = Parser::Ruby18.new
-    when '1.9' then parser = Parser::Ruby19.new
-    when '2.0' then parser = Parser::Ruby20.new
-    when '2.1' then parser = Parser::Ruby21.new
-    when '2.2' then parser = Parser::Ruby22.new
-    when '2.3' then parser = Parser::Ruby23.new
-    when '2.4' then parser = Parser::Ruby24.new
-    when '2.5' then parser = Parser::Ruby25.new
-    when '2.6' then parser = Parser::Ruby26.new
-    when '2.7' then parser = Parser::Ruby27.new
-    when 'mac' then parser = Parser::MacRuby.new
-    when 'ios' then parser = Parser::RubyMotion.new
-    else raise "Unrecognized Ruby version #{version}"
-    end
-
-    parser.diagnostics.consumer = lambda do |diagnostic|
-      @diagnostics << diagnostic
-    end
-
-    parser
-  end
-
-  def with_versions(versions)
-    (versions & ALL_VERSIONS).each do |version|
-      @diagnostics.clear
-
-      parser = parser_for_ruby_version(version)
-      yield version, parser
-    end
-  end
-
-  def assert_source_range(begin_pos, end_pos, range, version, what)
-    assert range.is_a?(Parser::Source::Range),
-           "(#{version}) #{range.inspect}.is_a?(Source::Range) for #{what}"
-
-    assert_equal begin_pos, range.begin_pos,
-                 "(#{version}) begin of #{what}"
-
-    assert_equal end_pos, range.end_pos,
-                 "(#{version}) end of #{what}"
-  end
-
-  # Use like this:
-  # ~~~
-  # assert_parses(
-  #   s(:send, s(:lit, 10), :+, s(:lit, 20))
-  #   %q{10 + 20},
-  #   %q{~~~~~~~ expression
-  #     |   ^ operator
-  #     |     ~~ expression (lit)
-  #     },
-  #     %w(1.8 1.9) # optional
-  # )
-  # ~~~
-  def assert_parses(ast, code, source_maps='', versions=ALL_VERSIONS)
-    with_versions(versions) do |version, parser|
-      try_parsing(ast, code, parser, source_maps, version)
-    end
-
-    # Also try parsing with lexer set to use UTF-32LE internally
-    with_versions(versions) do |version, parser|
-      parser.instance_eval { @lexer.force_utf32 = true }
-      try_parsing(ast, code, parser, source_maps, version)
-    end
-  end
-
-  def try_parsing(ast, code, parser, source_maps, version)
-    source_file = Parser::Source::Buffer.new('(assert_parses)')
-    source_file.source = code
-
-    begin
-      parsed_ast = parser.parse(source_file)
-    rescue => exc
-      backtrace = exc.backtrace
-      Exception.instance_method(:initialize).bind(exc).
-        call("(#{version}) #{exc.message}")
-      exc.set_backtrace(backtrace)
-      raise
-    end
-
-    if ast.nil?
-      assert_nil parsed_ast, "(#{version}) AST equality"
-      return
-    end
-
-    assert_equal ast, parsed_ast,
-                 "(#{version}) AST equality"
-
-    parse_source_map_descriptions(source_maps) \
-        do |begin_pos, end_pos, map_field, ast_path, line|
-
-      astlet = traverse_ast(parsed_ast, ast_path)
-
-      if astlet.nil?
-        # This is a testsuite bug.
-        raise "No entity with AST path #{ast_path} in #{parsed_ast.inspect}"
-      end
-
-      assert astlet.frozen?
-
-      assert astlet.location.respond_to?(map_field),
-             "(#{version}) #{astlet.location.inspect}.respond_to?(#{map_field.inspect}) for:\n#{parsed_ast.inspect}"
-
-      range = astlet.location.send(map_field)
-
-      assert_source_range(begin_pos, end_pos, range, version, line.inspect)
-    end
-
-    assert parser.instance_eval { @lexer }.cmdarg.empty?,
-      "(#{version}) expected cmdarg to be empty after parsing"
-  end
-
-  # Use like this:
-  # ~~~
-  # assert_diagnoses(
-  #   [:warning, :ambiguous_prefix, { prefix: '*' }],
-  #   %q{foo *bar},
-  #   %q{    ^ location
-  #     |     ~~~ highlights (0)})
-  # ~~~
-  def assert_diagnoses(diagnostic, code, source_maps='', versions=ALL_VERSIONS)
-    with_versions(versions) do |version, parser|
-      source_file = Parser::Source::Buffer.new('(assert_diagnoses)')
-      source_file.source = code
-
-      begin
-        parser = parser.parse(source_file)
-      rescue Parser::SyntaxError
-        # do nothing; the diagnostic was reported
-      end
-
-      assert_equal 1, @diagnostics.count,
-                   "(#{version}) emits a single diagnostic, not\n" \
-                   "#{@diagnostics.map(&:render).join("\n")}"
-
-      emitted_diagnostic = @diagnostics.first
-
-      level, reason, arguments = diagnostic
-      arguments ||= {}
-      message     = Parser::MESSAGES[reason] % arguments
-
-      assert_equal level, emitted_diagnostic.level
-      assert_equal reason, emitted_diagnostic.reason
-      assert_equal arguments, emitted_diagnostic.arguments
-      assert_equal message, emitted_diagnostic.message
-
-      parse_source_map_descriptions(source_maps) \
-          do |begin_pos, end_pos, map_field, ast_path, line|
-
-        case map_field
-        when 'location'
-          assert_source_range begin_pos, end_pos,
-                              emitted_diagnostic.location,
-                              version, 'location'
-
-        when 'highlights'
-          index = ast_path.first.to_i
-
-          assert_source_range begin_pos, end_pos,
-                              emitted_diagnostic.highlights[index],
-                              version, "#{index}th highlight"
-
-        else
-          raise "Unknown diagnostic range #{map_field}"
-        end
-      end
-    end
-  end
-
-  # Use like this:
-  # ~~~
-  # assert_diagnoses_many(
-  #   [
-  #     [:warning, :ambiguous_literal],
-  #     [:error, :unexpected_token, { :token => :tLCURLY }]
-  #   ],
-  #   %q{m /foo/ {}},
-  #   SINCE_2_4)
-  # ~~~
-  def assert_diagnoses_many(diagnostics, code, versions=ALL_VERSIONS)
-    with_versions(versions) do |version, parser|
-      source_file = Parser::Source::Buffer.new('(assert_diagnoses_many)')
-      source_file.source = code
-
-      begin
-        parser = parser.parse(source_file)
-      rescue Parser::SyntaxError
-        # do nothing; the diagnostic was reported
-      end
-
-      assert_equal diagnostics.count, @diagnostics.count
-
-      diagnostics.zip(@diagnostics) do |expected_diagnostic, actual_diagnostic|
-        level, reason, arguments = expected_diagnostic
-        arguments ||= {}
-        message     = Parser::MESSAGES[reason] % arguments
-
-        assert_equal level, actual_diagnostic.level
-        assert_equal reason, actual_diagnostic.reason
-        assert_equal arguments, actual_diagnostic.arguments
-        assert_equal message, actual_diagnostic.message
-      end
-    end
-  end
-
-  def refute_diagnoses(code, versions=ALL_VERSIONS)
-    with_versions(versions) do |version, parser|
-      source_file = Parser::Source::Buffer.new('(refute_diagnoses)')
-      source_file.source = code
-
-      begin
-        parser = parser.parse(source_file)
-      rescue Parser::SyntaxError
-        # do nothing; the diagnostic was reported
-      end
-
-      assert_empty @diagnostics,
-                   "(#{version}) emits no diagnostics, not\n" \
-                   "#{@diagnostics.map(&:render).join("\n")}"
-    end
-  end
-
-  def assert_context(context, code, versions=ALL_VERSIONS)
-    with_versions(versions) do |version, parser|
-      source_file = Parser::Source::Buffer.new('(assert_context)')
-      source_file.source = code
-
-      begin
-        parser.parse(source_file)
-      rescue Parser::SyntaxError
-        # do nothing; the diagnostic was reported
-      end
-
-      assert_equal parser.context.stack, context, "(#{version}) parsing context"
-    end
-  end
-
-  SOURCE_MAP_DESCRIPTION_RE =
-      /(?x)
-       ^(?# $1 skip)            ^(\s*)
-        (?# $2 highlight)        ([~\^]+)
-                                 \s+
-        (?# $3 source_map_field) ([a-z_]+)
-        (?# $5 ast_path)         (\s+\(([a-z_.\/0-9]+)\))?
-                                $/
-
-  def parse_source_map_descriptions(descriptions)
-    unless block_given?
-      return to_enum(:parse_source_map_descriptions, descriptions)
-    end
-
-    descriptions.each_line do |line|
-      # Remove leading "     |", if it exists.
-      line = line.sub(/^\s*\|/, '').rstrip
-
-      next if line.empty?
-
-      if (match = SOURCE_MAP_DESCRIPTION_RE.match(line))
-        begin_pos        = match[1].length
-        end_pos          = begin_pos + match[2].length
-        source_map_field = match[3]
-
-        if match[5]
-          ast_path = match[5].split('.')
-        else
-          ast_path = []
-        end
-
-        yield begin_pos, end_pos, source_map_field, ast_path, line
-      else
-        raise "Cannot parse source map description line: #{line.inspect}."
-      end
-    end
-  end
-
-  def traverse_ast(ast, path)
-    path.inject(ast) do |astlet, path_component|
-      # Split "dstr/2" to :dstr and 1
-      type_str, index_str = path_component.split('/')
-
-      type  = type_str.to_sym
-
-      if index_str.nil?
-        index = 0
-      else
-        index = index_str.to_i - 1
-      end
-
-      matching_children = \
-        astlet.children.select do |child|
-          AST::Node === child && child.type == type
-        end
-
-      matching_children[index]
-    end
-  end
-end

data/test/racc_coverage_helper.rb

@@ -1,133 +0,0 @@
-# frozen_string_literal: true
-
-require 'racc/grammarfileparser'
-
-# Unfortunately, Ruby's Coverage module ignores module_eval statements,
-# which Racc uses to map `parser.y` locations in the generated
-# `parser.rb`.
-module RaccCoverage
-  @coverage  = {}
-  @base_path = nil
-  @trace     = nil
-
-  def self.start(parsers, base_path)
-    @base_path = base_path
-
-    parsers.each do |parser|
-      @coverage[parser] = extract_interesting_lines(parser, base_path)
-    end
-
-    @trace = TracePoint.new(:line) do |trace|
-      lineno = trace.lineno - 1
-
-      if (line_coverage = @coverage[trace.path])
-        if line_coverage[lineno]
-          line_coverage[lineno] += 1
-        end
-      end
-    end
-    @trace.enable
-  end
-
-  def self.stop
-    @trace.disable
-  end
-
-  # Ruby's TracePoint#lineno will point only on "interesting" lines,
-  # i.e.: only code (no comments or empty lines), no `end` keywords,
-  # and for multi-line statements, only the first line of the statement.
-  #
-  # This method implements a very dumb Ruby parser, which skips empty lines
-  # or lines with just comments, `end` keywords, and correctly handles
-  # multi-line statements of the following form:
-  #
-  #  * All lines of the statement except the last must end with `,`, `.` or `(`.
-  #
-  # Coverage can be disabled for code regions with annotations :nocov: and :cov:.
-  #
-  # Also, for best results, all actions should be delimited by at least
-  # one non-action line.
-  #
-  def self.extract_interesting_lines(parser, base_path)
-    grammar_source = File.join(@base_path, parser)
-    grammar_file   = Racc::GrammarFileParser.parse_file(grammar_source)
-
-    ruby_sources = [
-      # Header and footer aren't passed through module_eval
-      # in Racc-generated file, so the location info is lost.
-      *grammar_file.params.inner,
-    ].compact
-
-    grammar_file.grammar.each_rule do |rule|
-      source = rule.action.source
-      next if source.nil?
-
-      ruby_sources << source
-    end
-
-    lines = []
-
-    ruby_sources.each do |source|
-      first_line = source.lineno
-
-      state = :first_line
-
-      source.text.each_line.with_index do |line, index|
-        line = line.strip
-
-        continues = line.end_with?(',')   ||
-                      line.end_with?('(') ||
-                      line.end_with?('.')
-
-        case state
-        when :first_line
-          if line =~ /:nocov/
-            state = :nocov
-            next
-          elsif line.empty?   ||
-                  line == 'end' ||
-                  line.start_with?('#')
-            next
-          elsif continues
-            state = :mid_line
-          end
-
-          lines[first_line + index - 1] = 0
-
-        when :mid_line
-          unless continues
-            state = :first_line
-          end
-
-        when :nocov
-          if line =~ /:cov:/
-            state = :first_line
-          end
-        end
-      end
-    end
-
-    lines
-  end
-
-  def self.result
-    result =
-      @coverage.map do |parser, coverage|
-        [File.join(@base_path, parser), coverage]
-      end
-
-    Hash[result]
-  end
-end
-
-class << SimpleCov
-  def result_with_racc_coverage
-    @result ||= SimpleCov::Result.new(
-                  Coverage.result.merge(RaccCoverage.result))
-
-    result_without_racc_coverage
-  end
-
-  alias result_without_racc_coverage result
-  alias result result_with_racc_coverage
-end