module Lrama
  class Grammar
    class RuleBuilder
      attr_accessor lhs: Lexer::Token
      attr_accessor line: Integer?
      attr_reader lhs_tag: Lexer::Token::Tag?
      attr_reader rhs: Array[Lexer::Token]
      attr_reader user_code: Lexer::Token::UserCode?
      attr_reader precedence_sym: Grammar::Symbol?

      @rule_counter: Counter
      @midrule_action_counter: Counter
      @parameterizing_rule_resolver: Grammar::ParameterizingRule::Resolver
      @position_in_original_rule_rhs: Integer?
      @skip_preprocess_references: bool
      @user_code: Lexer::Token::UserCode?
      @rule_builders_for_parameterizing_rules: Array[RuleBuilder]
      @rule_builders_for_derived_rules: Array[RuleBuilder]
      @rules: Array[Rule]
      @replaced_rhs: Array[Lexer::Token]
      @parameterizing_rules: Array[Rule]
      @midrule_action_rules: Array[Rule]

      def initialize: (Counter rule_counter, Counter midrule_action_counter, Grammar::ParameterizingRule::Resolver parameterizing_rule_resolver, ?Integer position_in_original_rule_rhs, ?lhs_tag: Lexer::Token::Tag?, ?skip_preprocess_references: bool) -> void
      def add_rhs: (Lexer::Token rhs) -> void
      def has_inline_rules?: -> bool
      def resolve_inline_rules: -> Array[RuleBuilder]
      def user_code=: (Lexer::Token::UserCode? user_code) -> void
      def precedence_sym=: (Grammar::Symbol? precedence_sym) -> void
      def complete_input: () -> void
      def setup_rules: () -> void
      def rules: () -> Array[Rule]

      private

      def freeze_rhs: () -> void
      def preprocess_references: () -> void
      def build_rules: () -> void
      def process_rhs: () -> void
      def lhs_s_value: (Lexer::Token::InstantiateRule token, Grammar::Binding bindings) -> String
      def resolve_inline: () -> void
      def resolve_inline_rhs: (RuleBuilder rule_builder, Grammar::ParameterizingRule::Rhs inline_rhs, Integer index, ?Binding bindings) -> void
      def replace_inline_user_code: (Grammar::ParameterizingRule::Rhs inline_rhs, Integer index) -> Lexer::Token::UserCode?
      def numberize_references: () -> void
      def flush_user_code: () -> void
    end
  end
end