ibex 0.1.0

data/sig/ibex/frontend/bootstrap_parser.rbs

@@ -0,0 +1,80 @@
+# Generated from lib/ibex/frontend/bootstrap_parser.rb with RBS::Inline
+
+module Ibex
+  module Frontend
+    # Handwritten parser used only to regenerate the self-hosted frontend.
+    class BootstrapParser
+      include BootstrapParserDeclarations
+
+      include BootstrapParserRules
+
+      @mode: Symbol
+
+      @index: Integer
+
+      @tokens: Array[Token]
+
+      # @rbs (String | Array[Token] source, ?file: String, ?mode: Symbol) -> void
+      def initialize: (String | Array[Token] source, ?file: String, ?mode: Symbol) -> void
+
+      # @rbs () -> AST::Root
+      def parse: () -> AST::Root
+
+      private
+
+      # @rbs () -> String
+      def parse_constant_path: () -> String
+
+      # @rbs () -> String
+      def parse_symbol_name: () -> String
+
+      # @rbs () -> Token
+      def expect_symbol: () -> Token
+
+      # @rbs (Array[String] values) -> Token
+      def expect_one_of: (Array[String] values) -> Token
+
+      # @rbs (String value) -> bool
+      def keyword?: (String value) -> bool
+
+      # @rbs (String value) -> Token
+      def expect_keyword: (String value) -> Token
+
+      # @rbs (Symbol type) -> (Token | false)
+      def accept: (Symbol type) -> (Token | false)
+
+      # @rbs (Symbol type) -> Token
+      def expect: (Symbol type) -> Token
+
+      # @rbs () -> Token
+      def current: () -> Token
+
+      # @rbs () -> Token
+      def lookahead: () -> Token
+
+      # @rbs () -> Token
+      def advance: () -> Token
+
+      # @rbs () -> AST::user_code
+      def parse_user_code: () -> AST::user_code
+
+      # @rbs (Location location, String feature) -> void
+      def extended_only!: (Location location, String feature) -> void
+
+      # @rbs (String | Symbol expected) -> bot
+      def fail_expected: (String | Symbol expected) -> bot
+
+      # @rbs (Location location, String message) -> bot
+      def fail_at: (Location location, String message) -> bot
+
+      # @rbs (Token token) -> String
+      def token_string: (Token token) -> String
+
+      # @rbs (Token token) -> Integer
+      def token_integer: (Token token) -> Integer
+
+      # @rbs (Token token) -> user_code_token
+      def token_user_code: (Token token) -> user_code_token
+    end
+  end
+end

data/sig/ibex/frontend/dsl.rbs

@@ -0,0 +1,124 @@
+# Generated from lib/ibex/frontend/dsl.rb with RBS::Inline
+
+module Ibex
+  module Frontend
+    # Builds the same Grammar AST as the text frontend through a Ruby API.
+    module DSL
+      # @rbs (class_name: Object, ?superclass: Object?, ?file: String) { (Builder) -> void } -> AST::Root
+      def self?.grammar: (class_name: Object, ?superclass: Object?, ?file: String) { (Builder) -> void } -> AST::Root
+
+      # Mutable definition context whose output is an immutable-shape AST.
+      class Builder
+        @user_code: AST::user_code
+
+        @rules: Array[AST::Rule]
+
+        @declarations: Array[AST::declaration]
+
+        @line: Integer
+
+        @file: String
+
+        @superclass: String?
+
+        @class_name: String
+
+        # @rbs (class_name: Object, superclass: Object?, file: String) -> void
+        def initialize: (class_name: Object, superclass: Object?, file: String) -> void
+
+        # @rbs (*Object names) -> void
+        def token: (*Object names) -> void
+
+        # @rbs (*Object names) -> void
+        def options: (*Object names) -> void
+
+        # @rbs (Integer conflicts) -> void
+        def expect: (Integer conflicts) -> void
+
+        # @rbs (Object name) -> void
+        def start: (Object name) -> void
+
+        # @rbs (Object name, Object expression) -> void
+        def convert: (Object name, Object expression) -> void
+
+        # @rbs (?direction: Symbol) { (PrecedenceBuilder) -> void } -> void
+        def precedence: (?direction: Symbol) { (PrecedenceBuilder) -> void } -> void
+
+        # @rbs (Object lhs) { (RuleBuilder) -> void } -> void
+        def rule: (Object lhs) { (RuleBuilder) -> void } -> void
+
+        # @rbs (Object name, Object code) -> void
+        def user_code: (Object name, Object code) -> void
+
+        # @rbs (Object name, ?as: Object?) -> AST::SymbolReference
+        def ref: (Object name, ?as: Object?) -> AST::SymbolReference
+
+        # @rbs (Object item) -> AST::Optional
+        def optional: (Object item) -> AST::Optional
+
+        # @rbs (Object item) -> AST::Star
+        def star: (Object item) -> AST::Star
+
+        # @rbs (Object item) -> AST::Plus
+        def plus: (Object item) -> AST::Plus
+
+        # @rbs (*Object alternatives) -> AST::Group
+        def group: (*Object alternatives) -> AST::Group
+
+        # @rbs (Object item, Object separator, ?nonempty: bool) -> AST::SeparatedList
+        def separated_list: (Object item, Object separator, ?nonempty: bool) -> AST::SeparatedList
+
+        # @rbs (Object code) -> AST::InlineAction
+        def inline: (Object code) -> AST::InlineAction
+
+        # @rbs () -> AST::Root
+        def to_ast: () -> AST::Root
+
+        # @rbs (Object item) -> AST::item
+        def normalize_item: (Object item) -> AST::item
+
+        # @rbs () -> Location
+        def next_location: () -> Location
+      end
+
+      # Collects ordered associativity levels.
+      class PrecedenceBuilder
+        attr_reader levels: Array[AST::PrecedenceLevel]
+
+        @grammar: Builder
+
+        # @rbs (Builder grammar) -> void
+        def initialize: (Builder grammar) -> void
+
+        # @rbs (*Object symbols) -> void
+        def left: (*Object symbols) -> void
+
+        # @rbs (*Object symbols) -> void
+        def right: (*Object symbols) -> void
+
+        # @rbs (*Object symbols) -> void
+        def nonassoc: (*Object symbols) -> void
+
+        private
+
+        # @rbs (Symbol associativity, Array[Object] symbols) -> void
+        def add_level: (Symbol associativity, Array[Object] symbols) -> void
+      end
+
+      # Collects alternatives for one nonterminal.
+      class RuleBuilder
+        attr_reader alternatives: Array[AST::Alternative]
+
+        @grammar: Builder
+
+        @default_location: Location
+
+        # @rbs (Builder grammar, Location default_location) -> void
+        def initialize: (Builder grammar, Location default_location) -> void
+
+        # @rbs (*Object items, ?action: Object?, ?precedence: Object?) -> void
+        def alt: (*Object items, ?action: Object?, ?precedence: Object?) -> void
+      end
+    end
+  end
+end

data/sig/ibex/frontend/generated_parser.rbs

@@ -0,0 +1,163 @@
+# Generated from lib/ibex/frontend/generated_parser.rb with RBS::Inline
+
+module Ibex
+  module Frontend
+    class GeneratedParser < Ibex::Frontend::GeneratedParserBase
+      PARSER_TABLE_FORMAT_VERSION: ::Integer
+
+      TOKEN_IDS: untyped
+
+      TOKEN_NAMES: untyped
+
+      ACTIONS: untyped
+
+      GOTOS: untyped
+
+      DEFAULT_ACTIONS: untyped
+
+      PRODUCTIONS: untyped
+
+      PARSER_TABLES: untyped
+
+      def self.parser_tables: () -> untyped
+
+      DEBUG_ENABLED: bool
+
+      private def _ibex_action_0: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_1: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_2: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_3: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_4: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_7: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_8: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_9: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_10: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_11: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_12: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_13: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_14: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_15: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_16: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_17: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_18: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_19: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_20: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_21: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_22: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_23: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_24: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_25: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_26: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_27: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_28: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_29: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_30: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_31: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_32: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_33: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_34: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_35: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_36: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_37: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_38: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_39: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_42: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_43: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_44: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_45: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_46: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_47: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_48: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_49: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_50: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_51: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_52: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_53: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_54: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_55: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_56: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_57: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_58: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_59: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_60: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_61: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_62: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_63: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_64: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_65: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_66: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_67: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_68: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_69: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_70: (untyped val, untyped _values) -> untyped
+
+      private def _ibex_action_71: (untyped val, untyped _values) -> untyped
+    end
+  end
+end

data/sig/ibex/frontend/generated_parser_base.rbs

@@ -0,0 +1,114 @@
+# Generated from lib/ibex/frontend/generated_parser_base.rb with RBS::Inline
+
+module Ibex
+  module Frontend
+    # Semantic support and token delivery for the generated grammar parser.
+    class GeneratedParserBase < Runtime::Parser
+      @mode: Symbol
+
+      @adapter: TokenAdapter
+
+      # @rbs (Array[Token] tokens, ?mode: Symbol) -> void
+      def initialize: (Array[Token] tokens, ?mode: Symbol) -> void
+
+      # @rbs () -> AST::Root
+      def parse: () -> AST::Root
+
+      # @rbs () -> ([external_token, Token] | false)
+      def next_token: () -> ([ external_token, Token ] | false)
+
+      # @rbs (Integer? _token_id, Token? value, Array[untyped] _value_stack) -> bot
+      def on_error: (Integer? _token_id, Token? value, Array[untyped] _value_stack) -> bot
+
+      private
+
+      # @rbs (Token? token) -> void
+      def raise_contextual_error: (Token? token) -> void
+
+      # @rbs (Token? token) -> void
+      def raise_group_contextual_error: (Token? token) -> void
+
+      # @rbs () -> void
+      def raise_conversion_contextual_error: () -> void
+
+      # @rbs (Token? token) -> String
+      def expected_description: (Token? token) -> String
+
+      # @rbs (Token? token) -> String
+      def structural_expectation: (Token? token) -> String
+
+      # @rbs (Token class_token, Array[String] class_parts, Array[String]? superclass,
+      #   Array[AST::declaration] declarations, Array[AST::Rule] rules, AST::user_code user_code) -> AST::Root
+      def build_root: (Token class_token, Array[String] class_parts, Array[String]? superclass, Array[AST::declaration] declarations, Array[AST::Rule] rules, AST::user_code user_code) -> AST::Root
+
+      # @rbs (Token keyword, Array[String] names) -> AST::Tokens
+      def build_tokens: (Token keyword, Array[String] names) -> AST::Tokens
+
+      # @rbs (Token keyword, Symbol direction, Array[AST::PrecedenceLevel] levels) -> AST::Precedence
+      def build_precedence: (Token keyword, Symbol direction, Array[AST::PrecedenceLevel] levels) -> AST::Precedence
+
+      # @rbs (Token association, Array[String] symbols) -> AST::PrecedenceLevel
+      def build_precedence_level: (Token association, Array[String] symbols) -> AST::PrecedenceLevel
+
+      # @rbs (Token keyword, Array[String] names) -> AST::Options
+      def build_options: (Token keyword, Array[String] names) -> AST::Options
+
+      # @rbs (Token keyword, Token integer) -> AST::Expect
+      def build_expect: (Token keyword, Token integer) -> AST::Expect
+
+      # @rbs (Token keyword, String name) -> AST::Start
+      def build_start: (Token keyword, String name) -> AST::Start
+
+      # @rbs (Token keyword, Array[AST::Conversion] pairs) -> AST::Convert
+      def build_convert: (Token keyword, Array[AST::Conversion] pairs) -> AST::Convert
+
+      # @rbs (Token name_token, Token literal_token) -> AST::Conversion
+      def build_conversion: (Token name_token, Token literal_token) -> AST::Conversion
+
+      # @rbs (Token lhs, Array[AST::Alternative] alternatives) -> AST::Rule
+      def build_rule: (Token lhs, Array[AST::Alternative] alternatives) -> AST::Rule
+
+      # @rbs (Array[AST::item] items, Token? precedence) -> AST::Alternative
+      def build_alternative: (Array[AST::item] items, Token? precedence) -> AST::Alternative
+
+      # @rbs (AST::item? item) -> Location?
+      def item_start_location: (AST::item? item) -> Location?
+
+      # @rbs (Token token, [Token, Token]? named_reference, Array[Token] suffixes) -> AST::item
+      def build_symbol_reference: (Token token, [ Token, Token ]? named_reference, Array[Token] suffixes) -> AST::item
+
+      # @rbs (Token token) -> AST::InlineAction
+      def build_action: (Token token) -> AST::InlineAction
+
+      # @rbs (Token opening, Array[Array[AST::item]] alternatives, Array[Token] suffixes) -> AST::item
+      def build_group: (Token opening, Array[Array[AST::item]] alternatives, Array[Token] suffixes) -> AST::item
+
+      # @rbs (Token function, AST::item item, AST::item separator) -> AST::SeparatedList
+      def build_separated_list: (Token function, AST::item item, AST::item separator) -> AST::SeparatedList
+
+      # @rbs (AST::item item, Array[Token] suffixes) -> AST::item
+      def apply_suffixes: (AST::item item, Array[Token] suffixes) -> AST::item
+
+      # @rbs (AST::user_code blocks, Token token) -> AST::user_code
+      def append_user_code: (AST::user_code blocks, Token token) -> AST::user_code
+
+      # @rbs () -> AST::user_code
+      def empty_user_code: () -> AST::user_code
+
+      # @rbs (Location location, String feature) -> void
+      def extended_only!: (Location location, String feature) -> void
+
+      # @rbs (Location location, String message) -> bot
+      def fail_at: (Location location, String message) -> bot
+
+      # @rbs (Token token) -> String
+      def token_string: (Token token) -> String
+
+      # @rbs (Token token) -> Integer
+      def token_integer: (Token token) -> Integer
+
+      # @rbs (Token token) -> user_code_token
+      def token_user_code: (Token token) -> user_code_token
+    end
+  end
+end

data/sig/ibex/frontend/lexer.rbs

@@ -0,0 +1,61 @@
+# Generated from lib/ibex/frontend/lexer.rb with RBS::Inline
+
+module Ibex
+  module Frontend
+    # Tokenizes a racc-compatible grammar while preserving source locations.
+    class Lexer
+      PUNCTUATION: Hash[String, Symbol]
+
+      USER_CODE: Regexp
+
+      @cursor: SourceCursor
+
+      # @rbs (String source, ?file: String) -> void
+      def initialize: (String source, ?file: String) -> void
+
+      # @rbs () -> Array[Token]
+      def tokenize: () -> Array[Token]
+
+      # @rbs () -> Token
+      def next_token: () -> Token
+
+      private
+
+      # @rbs (String character) -> Token
+      def scan_regular_token: (String character) -> Token
+
+      # @rbs () -> void
+      def skip_ignored: () -> void
+
+      # @rbs () -> void
+      def skip_block_comment: () -> void
+
+      # @rbs () -> bool
+      def line_start?: () -> bool
+
+      # @rbs () -> Token
+      def scan_user_code: () -> Token
+
+      # @rbs () -> Token
+      def scan_scope: () -> Token
+
+      # @rbs () -> Token
+      def scan_identifier: () -> Token
+
+      # @rbs () -> Token
+      def scan_integer: () -> Token
+
+      # @rbs () -> Token
+      def scan_literal: () -> Token
+
+      # @rbs () -> Token
+      def scan_punctuation: () -> Token
+
+      # @rbs (Symbol type, Regexp pattern) ?{ (String) -> token_value } -> Token
+      def scan_match: (Symbol type, Regexp pattern) ?{ (String) -> token_value } -> Token
+
+      # @rbs (Symbol type, token_value value, ?Location location) -> Token
+      def token: (Symbol type, token_value value, ?Location location) -> Token
+    end
+  end
+end

data/sig/ibex/frontend/parser/declarations.rbs

@@ -0,0 +1,56 @@
+# Generated from lib/ibex/frontend/parser/declarations.rb with RBS::Inline
+
+module Ibex
+  module Frontend
+    # Parses the declaration section of a grammar.
+    module BootstrapParserDeclarations
+      DECLARATIONS: Array[String]
+
+      ASSOCIATIVITIES: Array[String]
+
+      private
+
+      # @rbs () -> Array[AST::declaration]
+      def parse_declarations: () -> Array[AST::declaration]
+
+      # @rbs () -> void
+      def parse_pragmas: () -> void
+
+      # @rbs () -> AST::declaration
+      def parse_declaration: () -> AST::declaration
+
+      # @rbs () -> AST::Tokens
+      def parse_tokens: () -> AST::Tokens
+
+      # @rbs () -> AST::Precedence
+      def parse_precedence: () -> AST::Precedence
+
+      # @rbs (String closing) -> Array[AST::PrecedenceLevel]
+      def precedence_levels: (String closing) -> Array[AST::PrecedenceLevel]
+
+      # @rbs () -> AST::Options
+      def parse_options: () -> AST::Options
+
+      # @rbs () -> AST::Expect
+      def parse_expect: () -> AST::Expect
+
+      # @rbs () -> AST::Start
+      def parse_start: () -> AST::Start
+
+      # @rbs () -> AST::Convert
+      def parse_convert: () -> AST::Convert
+
+      # @rbs (Integer line) -> Array[Token]
+      def tokens_on_line: (Integer line) -> Array[Token]
+
+      # @rbs (Array[Token] tokens, Location location) -> String
+      def decode_conversion: (Array[Token] tokens, Location location) -> String
+
+      # @rbs () -> bool
+      def declaration_start?: () -> bool
+
+      # @rbs () -> bool
+      def association_start?: () -> bool
+    end
+  end
+end

data/sig/ibex/frontend/parser/rules.rbs

@@ -0,0 +1,48 @@
+# Generated from lib/ibex/frontend/parser/rules.rb with RBS::Inline
+
+module Ibex
+  module Frontend
+    # Parses productions and extended RHS items.
+    module BootstrapParserRules
+      EXTENDED_SUFFIXES: Hash[Symbol, singleton(AST::Optional) | singleton(AST::Star) | singleton(AST::Plus)]
+
+      private
+
+      # @rbs () -> Array[AST::Rule]
+      def parse_rules: () -> Array[AST::Rule]
+
+      # @rbs () -> AST::Rule
+      def parse_rule: () -> AST::Rule
+
+      # @rbs (Token lhs) -> AST::Alternative
+      def parse_alternative: (Token lhs) -> AST::Alternative
+
+      # @rbs () -> AST::item
+      def parse_item: () -> AST::item
+
+      # @rbs () -> AST::InlineAction
+      def parse_action: () -> AST::InlineAction
+
+      # @rbs () -> String?
+      def parse_named_reference: () -> String?
+
+      # @rbs (AST::item item) -> AST::item
+      def parse_suffix: (AST::item item) -> AST::item
+
+      # @rbs () -> AST::item
+      def parse_group: () -> AST::item
+
+      # @rbs () -> AST::SeparatedList
+      def parse_separated_list: () -> AST::SeparatedList
+
+      # @rbs (Token lhs) -> bool
+      def alternative_end?: (Token lhs) -> bool
+
+      # @rbs (Token lhs) -> bool
+      def rule_start?: (Token lhs) -> bool
+
+      # @rbs () -> bool
+      def separated_list?: () -> bool
+    end
+  end
+end

data/sig/ibex/frontend/parser.rbs

@@ -0,0 +1,16 @@
+# Generated from lib/ibex/frontend/parser.rb with RBS::Inline
+
+module Ibex
+  module Frontend
+    # Public grammar parser backed by Ibex's generated LR frontend.
+    class Parser
+      attr_reader implementation: GeneratedParser
+
+      # @rbs (String | Array[Token] source, ?file: String, ?mode: Symbol) -> void
+      def initialize: (String | Array[Token] source, ?file: String, ?mode: Symbol) -> void
+
+      # @rbs () -> AST::Root
+      def parse: () -> AST::Root
+    end
+  end
+end

data/sig/ibex/frontend/regenerator.rbs

@@ -0,0 +1,16 @@
+# Generated from lib/ibex/frontend/regenerator.rb with RBS::Inline
+
+module Ibex
+  module Frontend
+    # Builds the committed frontend parser from its canonical Ibex grammar.
+    module Regenerator
+      GRAMMAR_PATH: String
+
+      # @rbs () -> String
+      def self?.generate: () -> String
+
+      # @rbs () -> String
+      def self?.relative_grammar_path: () -> String
+    end
+  end
+end