rusa 0.1.0

data/lib/rusa/grammar/action_capture.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require "ripper"
+
+module Rusa
+  module Grammar
+    # Captures Ruby block source so semantic actions can be emitted into generated parsers.
+    module ActionCapture
+      BLOCK_OPENERS = %i[on_lbrace].freeze
+      PUSH_TOKENS = %i[on_lbrace on_lbracket on_lparen].freeze
+      POP_TOKENS = %i[on_rbrace on_rbracket on_rparen].freeze
+      BLOCK_KEYWORDS = %w[
+        do begin case class module def if unless while until for
+      ].freeze
+
+      module_function
+
+      #: (Proc) -> String?
+      def capture(action)
+        file, line = action.source_location
+        return nil unless file && line && File.file?(file)
+
+        source = File.readlines(file)[(line - 1)..]&.join
+        return nil unless source
+
+        block_source = extract_block(source)
+        block_source ? "lambda #{block_source}" : nil
+      end
+
+      #: (String) -> String?
+      def extract_block(source)
+        tokens = Ripper.lex(source)
+        opener_index = tokens.index do |token|
+          _position, type, text, = token
+          block_opener?(type, text)
+        end
+        return nil unless opener_index
+
+        stack = [] #: Array[[Symbol, String]]
+        start_offset = nil
+        block_tokens = block_tokens_from(tokens, opener_index)
+
+        block_tokens.each do |token|
+          position, type, text, = token
+          offset = offset_for(source, position)
+          start_offset ||= offset
+
+          case structural_event(type, text)
+          when :push
+            stack << closing_token_for(type, text)
+          when :pop
+            expected = stack.last
+            next unless expected == [type, text]
+
+            stack.pop
+            return source[start_offset...(offset + text.length)] if stack.empty?
+          end
+        end
+
+        nil
+      end
+
+      #: (Symbol, String) -> bool
+      def block_opener?(type, text)
+        BLOCK_OPENERS.include?(type) || (type == :on_kw && text == "do")
+      end
+
+      #: (Symbol, String) -> Symbol?
+      def structural_event(type, text)
+        return :push if PUSH_TOKENS.include?(type)
+        return :push if type == :on_kw && BLOCK_KEYWORDS.include?(text)
+        return :pop if POP_TOKENS.include?(type)
+        return :pop if type == :on_kw && text == "end"
+
+        nil
+      end
+
+      #: (Symbol, String) -> [Symbol, String]
+      def closing_token_for(type, text)
+        case [type, text]
+        when [:on_lbrace, "{"]
+          [:on_rbrace, "}"]
+        when [:on_lbracket, "["]
+          [:on_rbracket, "]"]
+        when [:on_lparen, "("]
+          [:on_rparen, ")"]
+        else
+          [:on_kw, "end"]
+        end
+      end
+
+      #: (String, [Integer, Integer]) -> Integer
+      def offset_for(source, position)
+        line_number, column = position
+        line_offsets = cached_line_offsets(source)
+
+        line_offsets[line_number - 1] + column
+      end
+
+      #: (Array[[[Integer, Integer], Symbol, String, Ripper::Lexer::State]], Integer) -> Array[[[Integer, Integer], Symbol, String, Ripper::Lexer::State]]
+      def block_tokens_from(tokens, opener_index)
+        tokens[opener_index..] || []
+      end
+
+      #: (String) -> Array[Integer]
+      def cached_line_offsets(source)
+        line_offsets_cache[source.object_id] ||= build_line_offsets(source)
+      end
+
+      #: () -> Hash[Integer, Array[Integer]]
+      def line_offsets_cache
+        @line_offsets_cache ||= {} #: Hash[Integer, Array[Integer]]
+      end
+
+      #: (String) -> Array[Integer]
+      def build_line_offsets(source)
+        offsets = [0]
+
+        source.each_line.reduce(0) do |acc, line|
+          offsets << acc + line.length
+          acc + line.length
+        end
+
+        offsets
+      end
+    end
+  end
+end

data/lib/rusa/grammar/dsl.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Rusa
+  module Grammar
+    # DSL evaluates the Ruby grammar definition and builds a Grammar object.
+    class DSL
+      attr_reader :grammar #: Grammar
+
+      #: () -> void
+      def initialize
+        @grammar = Grammar.new
+        @current_rule = nil
+        @precedence_level = 0
+      end
+
+      #: (Symbol | String, String | Regexp) -> TerminalSymbol
+      def token(name, pattern)
+        grammar.add_terminal(name, normalize_token_pattern(pattern))
+      end
+
+      #: (Regexp) -> Regexp
+      def skip(pattern)
+        grammar.add_skip_pattern(anchor_regexp(pattern))
+      end
+
+      #: (*Symbol | String) -> Array[Symbol | String]
+      def left(*tokens)
+        register_precedence(:left, tokens)
+      end
+
+      #: (*Symbol | String) -> Array[Symbol | String]
+      def right(*tokens)
+        register_precedence(:right, tokens)
+      end
+
+      #: (*Symbol | String) -> Array[Symbol | String]
+      def nonassoc(*tokens)
+        register_precedence(:nonassoc, tokens)
+      end
+
+      #: (Symbol | String) -> NonterminalSymbol
+      def start(symbol)
+        grammar.start_symbol = symbol.to_sym
+        grammar.add_nonterminal(symbol)
+      end
+
+      #: (Symbol | String) { (self) [self: self] -> void } -> void
+      def rule(name, &block)
+        raise InvalidGrammarError, "nested rule declarations are not supported" if @current_rule
+
+        @current_rule = name.to_sym
+        grammar.add_nonterminal(@current_rule)
+        instance_eval(&(block or raise ArgumentError, "block is required"))
+      ensure
+        @current_rule = nil
+      end
+
+      #: (*Symbol | String) -> AltBuilder
+      #: (*Symbol | String) { (*Object) -> Object } -> AltBuilder
+      def alt(*symbols, &action)
+        raise InvalidGrammarError, "alt must be declared inside rule" unless @current_rule
+
+        production = Production.new(
+          @current_rule,
+          symbols,
+          action,
+          action_source: action ? ActionCapture.capture(action) : nil
+        )
+        grammar.add_production(production)
+        AltBuilder.new(production)
+      end
+
+      private
+
+      #: (Symbol, Array[Symbol | String]) -> Array[Symbol | String]
+      def register_precedence(associativity, tokens)
+        @precedence_level += 1
+        tokens.each do |token|
+          grammar.set_precedence(token, @precedence_level, associativity)
+        end
+        tokens
+      end
+
+      #: (String | Regexp) -> Regexp
+      def normalize_token_pattern(pattern)
+        if pattern.is_a?(String)
+          source = "\\A#{Regexp.escape(pattern)}"
+          source = "#{source}\\b" if pattern.match?(/\A[a-zA-Z_]\w*\z/)
+          Regexp.new(source)
+        else
+          anchor_regexp(pattern)
+        end
+      end
+
+      #: (Regexp) -> Regexp
+      def anchor_regexp(pattern)
+        return pattern if pattern.source.start_with?("\\A")
+
+        Regexp.new("\\A(?:#{pattern.source})", pattern.options)
+      end
+    end
+
+    # AltBuilder allows precedence and source overrides to be chained from alt.
+    class AltBuilder
+      #: (Production) -> void
+      def initialize(production)
+        @production = production
+      end
+
+      #: (Symbol | String) -> self
+      def prec(token)
+        @production.context_precedence = token.to_sym
+        self
+      end
+
+      #: (String) -> self
+      def action(source)
+        @production.action_source = source
+        self
+      end
+    end
+  end
+end

data/lib/rusa/grammar/grammar.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+module Rusa
+  module Grammar
+    # Grammar keeps the normalized internal representation of the DSL.
+    class Grammar
+      AUGMENTED_START = :"$start"
+      END_OF_INPUT = :"$end"
+
+      attr_accessor :start_symbol #: Symbol?
+      attr_reader :terminals #: Hash[Symbol, TerminalSymbol]
+      attr_reader :nonterminals #: Hash[Symbol, NonterminalSymbol]
+      attr_reader :productions #: Array[Production]
+      attr_reader :precedences #: Hash[Symbol, Precedence]
+      attr_reader :skip_patterns #: Array[Regexp]
+      attr_reader :warnings #: Array[String]
+
+      #: () -> void
+      def initialize
+        @terminals = {} #: Hash[Symbol, TerminalSymbol]
+        @nonterminals = {} #: Hash[Symbol, NonterminalSymbol]
+        @productions = [] #: Array[Production]
+        @precedences = {} #: Hash[Symbol, Precedence]
+        @skip_patterns = [] #: Array[Regexp]
+        @warnings = [] #: Array[String]
+        @start_symbol = nil
+        @augmented = false
+      end
+
+      #: (Symbol | String, String | Regexp) -> TerminalSymbol
+      def add_terminal(name, pattern)
+        name = name.to_sym
+        raise DuplicateTokenError, "terminal #{name} is already defined" if terminals.key?(name)
+        raise DuplicateTokenError, duplicate_nonterminal_message(name) if nonterminals.key?(name)
+
+        terminals[name] = TerminalSymbol.new(name, pattern)
+      end
+
+      #: (Symbol | String) -> NonterminalSymbol
+      def add_nonterminal(name)
+        name = name.to_sym
+        raise DuplicateRuleError, "#{name} is already defined as a terminal" if terminals.key?(name)
+
+        nonterminals[name] ||= NonterminalSymbol.new(name)
+      end
+
+      #: (Production) -> Production
+      def add_production(production)
+        add_nonterminal(production.lhs)
+        production.id = productions.length
+        productions << production
+        production
+      end
+
+      #: (Regexp) -> Regexp
+      def add_skip_pattern(pattern)
+        skip_patterns << pattern
+        pattern
+      end
+
+      #: (Symbol | String, Integer, Symbol) -> Precedence
+      def set_precedence(token, level, associativity)
+        precedence = Precedence.new(level, associativity)
+        precedences[token.to_sym] = precedence
+      end
+
+      #: (Symbol | String) -> Precedence?
+      def precedence_for(token)
+        precedences[token.to_sym]
+      end
+
+      #: (Symbol | String) -> Array[Production]
+      def productions_for(nonterminal)
+        productions.select { |production| production.lhs == nonterminal.to_sym }
+      end
+
+      #: () -> self
+      def augment!
+        return self if @augmented
+        current_start_symbol = required_start_symbol
+
+        add_nonterminal(current_start_symbol)
+        add_nonterminal(AUGMENTED_START)
+        terminals[END_OF_INPUT] ||= TerminalSymbol.new(END_OF_INPUT, /\z/)
+
+        augmented = Production.new(AUGMENTED_START, [current_start_symbol])
+        @productions.unshift(augmented)
+        reindex_productions!
+        @augmented = true
+        self
+      end
+
+      #: () -> self
+      def validate!
+        required_start_symbol
+
+        undefined = undefined_symbols
+        raise UndefinedSymbolError, "undefined symbols: #{undefined.join(', ')}" if undefined.any?
+
+        @warnings = unreachable_warnings
+
+        self
+      end
+
+      #: () -> Symbol
+      def augmented_start
+        AUGMENTED_START
+      end
+
+      #: () -> Production
+      def augmented_production
+        productions.find { |production| production.lhs == AUGMENTED_START } ||
+          raise(InvalidGrammarError, "grammar is not augmented")
+      end
+
+      #: () -> Hash[Symbol, TerminalSymbol | NonterminalSymbol]
+      def symbols
+        terminals.merge(nonterminals)
+      end
+
+      #: (Symbol | String) -> bool
+      def terminal?(name)
+        terminals.key?(name.to_sym)
+      end
+
+      #: (Symbol | String) -> bool
+      def nonterminal?(name)
+        nonterminals.key?(name.to_sym)
+      end
+
+      #: () -> String
+      def dump
+        productions.map { |production| "[#{production.id}] #{production}" }.join("\n")
+      end
+
+      private
+
+      #: (Symbol) -> String
+      def duplicate_nonterminal_message(name)
+        "#{name} is already defined as a nonterminal"
+      end
+
+      #: () -> Symbol
+      def required_start_symbol
+        raise NoStartSymbolError, "start symbol is not set" unless start_symbol
+
+        start_symbol
+      end
+
+      #: () -> Array[Symbol]
+      def undefined_symbols
+        productions
+          .flat_map { |production| undefined_symbols_in(production) }
+          .uniq
+      end
+
+      #: (Production) -> Array[Symbol]
+      def undefined_symbols_in(production)
+        production.rhs.reject { |symbol| defined_symbol?(symbol) }
+      end
+
+      #: (Symbol) -> bool
+      def defined_symbol?(symbol)
+        symbol == END_OF_INPUT || terminal?(symbol) || nonterminal?(symbol)
+      end
+
+      #: () -> Array[String]
+      def unreachable_warnings
+        current_start_symbol = required_start_symbol
+
+        unreachable_nonterminals.map do |name|
+          "nonterminal #{name} is unreachable from #{current_start_symbol}"
+        end
+      end
+
+      #: () -> Array[Production]
+      def reindex_productions!
+        productions.each_with_index do |production, index|
+          production.id = index
+        end
+      end
+
+      #: () -> Array[Symbol]
+      def unreachable_nonterminals
+        return [] unless start_symbol
+
+        reachable = [start_symbol.to_sym]
+        queue = reachable.dup
+
+        until queue.empty?
+          current = queue.shift
+          next_reachable_nonterminals(current, reachable).each do |symbol|
+            reachable << symbol
+            queue << symbol
+          end
+        end
+
+        nonterminals.keys.reject do |symbol|
+          symbol == AUGMENTED_START || reachable.include?(symbol)
+        end
+      end
+
+      #: (Symbol, Array[Symbol]) -> Array[Symbol]
+      def next_reachable_nonterminals(current, reachable)
+        productions_for(current)
+          .flat_map(&:rhs)
+          .select { |symbol| nonterminal?(symbol) }
+          .reject { |symbol| reachable.include?(symbol) }
+      end
+    end
+  end
+end

data/lib/rusa/grammar/precedence.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Rusa
+  module Grammar
+    # Operator precedence metadata used to resolve parser conflicts.
+    class Precedence
+      attr_reader :level #: Integer
+      attr_reader :associativity #: Symbol
+
+      #: (Integer, Symbol) -> void
+      def initialize(level, associativity)
+        @level = level
+        @associativity = associativity
+        freeze
+      end
+
+      #: (Object) -> bool
+      def ==(other)
+        other.is_a?(self.class) && other.level == level && other.associativity == associativity
+      end
+      alias eql? ==
+
+      #: () -> Integer
+      def hash
+        [level, associativity].hash
+      end
+    end
+  end
+end

data/lib/rusa/grammar/rule.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Rusa
+  module Grammar
+    # Production rules connect one nonterminal with a sequence of symbols.
+    class Production
+      attr_accessor :id #: Integer?
+      attr_accessor :lhs #: Symbol
+      attr_accessor :rhs #: Array[Symbol]
+      attr_accessor :action #: Proc?
+      attr_accessor :context_precedence #: Symbol?
+      attr_accessor :action_source #: String?
+
+      #: (Symbol | String, Array[Symbol | String], ?Proc?, ?context_precedence: Symbol | String?, ?action_source: String?) -> void
+      def initialize(
+        lhs,
+        rhs,
+        action = nil,
+        context_precedence: nil,
+        action_source: nil
+      )
+        @lhs = lhs.to_sym
+        @rhs = rhs.map(&:to_sym).freeze
+        @action = action
+        @context_precedence = context_precedence&.to_sym
+        @action_source = action_source
+        @id = nil
+      end
+
+      #: (Grammar) -> Symbol?
+      def precedence_token(grammar)
+        return context_precedence if context_precedence
+
+        rhs.reverse.find { |symbol| grammar.terminal?(symbol) }
+      end
+
+      #: (Grammar) -> Precedence?
+      def precedence(grammar)
+        token = precedence_token(grammar)
+        token ? grammar.precedence_for(token) : nil
+      end
+
+      #: () -> bool
+      def empty?
+        rhs.empty?
+      end
+
+      #: () -> String
+      def to_s
+        rendered_rhs = rhs.empty? ? "ε" : rhs.join(" ")
+        "#{lhs} -> #{rendered_rhs}"
+      end
+    end
+  end
+end

data/lib/rusa/grammar/symbol.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Rusa
+  module Grammar
+    # Terminal symbols are matched by the generated tokenizer.
+    class TerminalSymbol
+      attr_reader :name #: Symbol
+      attr_reader :pattern #: Regexp
+
+      #: (Symbol | String, String | Regexp) -> void
+      def initialize(name, pattern)
+        @name = name.to_sym
+        @pattern = pattern.is_a?(String) ? Regexp.new(Regexp.escape(pattern)) : pattern
+        freeze
+      end
+
+      #: () -> bool
+      def terminal?
+        true
+      end
+
+      #: () -> bool
+      def nonterminal?
+        false
+      end
+
+      #: (Object) -> bool
+      def ==(other)
+        other.is_a?(self.class) && other.name == name
+      end
+      alias eql? ==
+
+      #: () -> Integer
+      def hash
+        [self.class, name].hash
+      end
+    end
+
+    # Nonterminal symbols are expanded by grammar productions.
+    class NonterminalSymbol
+      attr_reader :name #: Symbol
+
+      #: (Symbol | String) -> void
+      def initialize(name)
+        @name = name.to_sym
+        freeze
+      end
+
+      #: () -> bool
+      def terminal?
+        false
+      end
+
+      #: () -> bool
+      def nonterminal?
+        true
+      end
+
+      #: (Object) -> bool
+      def ==(other)
+        other.is_a?(self.class) && other.name == name
+      end
+      alias eql? ==
+
+      #: () -> Integer
+      def hash
+        [self.class, name].hash
+      end
+    end
+  end
+end

data/lib/rusa/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Rusa
+  VERSION = "0.1.0"
+end

data/lib/rusa.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "rusa/version"
+require_relative "rusa/errors"
+require_relative "rusa/grammar/symbol"
+require_relative "rusa/grammar/rule"
+require_relative "rusa/grammar/precedence"
+require_relative "rusa/grammar/grammar"
+require_relative "rusa/grammar/action_capture"
+require_relative "rusa/grammar/dsl"
+require_relative "rusa/analysis/first_follow"
+require_relative "rusa/analysis/item"
+require_relative "rusa/analysis/item_set"
+require_relative "rusa/analysis/automaton"
+require_relative "rusa/analysis/parse_action"
+require_relative "rusa/analysis/conflict_resolver"
+require_relative "rusa/analysis/lalr_table"
+require_relative "rusa/generator/code_generator"
+require_relative "rusa/cli"
+
+module Rusa
+  #: () { (Grammar::DSL) [self: Grammar::DSL] -> void } -> Grammar::Grammar
+  def self.grammar(&block)
+    dsl = Grammar::DSL.new
+    dsl.instance_eval(&(block or raise ArgumentError, "block is required"))
+    grammar = dsl.grammar
+    grammar.augment!
+    grammar.validate!
+    grammar
+  end
+end

data/sig/generated/rusa/analysis/automaton.rbs

@@ -0,0 +1,25 @@
+# Generated from lib/rusa/analysis/automaton.rb with RBS::Inline
+
+module Rusa
+  module Analysis
+    # Automaton builds the canonical LR(0) state graph.
+    class Automaton
+      attr_reader states: Array[ItemSet]
+
+      attr_reader transitions: Hash[Integer, Hash[Symbol, Integer]]
+
+      # : (Grammar::Grammar) -> void
+      def initialize: (Grammar::Grammar) -> void
+
+      private
+
+      attr_reader grammar: Grammar::Grammar
+
+      # : () -> void
+      def build: () -> void
+
+      # : (Enumerable[Item]) -> Array[Array[Integer?]]
+      def kernel_key: (Enumerable[Item]) -> Array[Array[Integer?]]
+    end
+  end
+end