ibex 0.1.0 → 0.3.0

data/sig/ibex/frontend/ast.rbs

@@ -2,25 +2,49 @@
 
 module Ibex
   module Frontend
+    # Keeps the public Rule constructor compatible with ASTs built before parameters and inline rules existed.
+    module ASTRuleDefaults
+      # @rbs (*untyped arguments, **untyped keywords) -> void
+      def initialize: (*untyped arguments, **untyped keywords) -> void
+    end
+
     # Grammar frontend node types.
+    # rubocop:disable Metrics/ModuleLength -- the public node vocabulary is intentionally kept together.
     module AST
-      type declaration = Tokens | Precedence | Options | Expect | Start | Convert
+      type symbol_metadata = DisplayName | SemanticType
+
+      type declaration = Include | Tokens | Precedence | Options | Expect | ExpectRR | Start | Recovery | OnErrorReduce | GrammarTest | Lexer | Convert | Parameter | Printer | ParserConfiguration | symbol_metadata
 
-      type item = SymbolReference | InlineAction | Optional | Star | Plus | Group | SeparatedList
+      type lexer_entry = LexerRule | LexerState
+
+      type item = SymbolReference | ParameterizedReference | InlineAction | Optional | Star | Plus | Group | SeparatedList | Empty
 
       type user_code = Hash[String, Array[UserCode]]
 
+      class Rule < Struct[String | Array[String] | Array[Alternative] | Location | String? | bool]
+        attr_accessor lhs: String
+        attr_accessor parameters: Array[String]
+        attr_accessor alternatives: Array[Alternative]
+        attr_accessor loc: Location
+        attr_accessor documentation: String?
+        attr_accessor inline: bool
+        def self.new: (?lhs: String, ?parameters: Array[String]?, ?alternatives: Array[Alternative], ?loc: Location, ?documentation: String?, ?inline: bool?) -> instance
+                    | ({ ?lhs: String, ?parameters: Array[String]?, ?alternatives: Array[Alternative], ?loc: Location, ?documentation: String?, ?inline: bool? }) -> instance
+      end
+
       # Adds deterministic, recursively serializable hashes to Struct nodes.
-      # @rbs module-self Struct[untyped]
-      module Node : Struct[untyped]
-        def to_h: () -> untyped
+      # @rbs module-self Struct[Object?]
+      module Node : Struct[Object?]
+        # @rbs () -> Hash[Symbol, untyped]
+        def to_h: () -> Hash[Symbol, untyped]
 
         private
 
+        # @rbs (untyped value) -> untyped
         def serialize: (untyped value) -> untyped
       end
 
-      class Root < Struct[String | String? | Array[declaration] | Array[Rule] | user_code | Location]
+      class Root < Struct[String | String? | Array[declaration] | Array[Rule] | user_code | Location | bool? | Location?]
         attr_accessor class_name(): String
 
         attr_accessor superclass(): String?
@@ -33,17 +57,45 @@ module Ibex
 
         attr_accessor loc(): Location
 
-        def self.new: (?class_name: String, ?superclass: String?, ?declarations: Array[declaration], ?rules: Array[Rule], ?user_code: user_code, ?loc: Location) -> instance
-                    | ({ ?class_name: String, ?superclass: String?, ?declarations: Array[declaration], ?rules: Array[Rule], ?user_code: user_code, ?loc: Location }) -> instance
+        attr_accessor extended(): bool?
+
+        attr_accessor cst(): bool?
+
+        attr_accessor extended_loc(): Location?
+
+        def self.new: (?class_name: String, ?superclass: String?, ?declarations: Array[declaration], ?rules: Array[Rule], ?user_code: user_code, ?loc: Location, ?extended: bool?, ?cst: bool?, ?extended_loc: Location?) -> instance
+                    | ({ ?class_name: String, ?superclass: String?, ?declarations: Array[declaration], ?rules: Array[Rule], ?user_code: user_code, ?loc: Location, ?extended: bool?, ?cst: bool?, ?extended_loc: Location? }) -> instance
+      end
+
+      class Fragment < Struct[Array[declaration] | Array[Rule] | Location]
+        attr_accessor declarations(): Array[declaration]
+
+        attr_accessor rules(): Array[Rule]
+
+        attr_accessor loc(): Location
+
+        def self.new: (?declarations: Array[declaration], ?rules: Array[Rule], ?loc: Location) -> instance
+                    | ({ ?declarations: Array[declaration], ?rules: Array[Rule], ?loc: Location }) -> instance
       end
 
-      class Tokens < Struct[Array[String] | Location]
+      class Include < Struct[String | Location]
+        attr_accessor path(): String
+
+        attr_accessor loc(): Location
+
+        def self.new: (?path: String, ?loc: Location) -> instance
+                    | ({ ?path: String, ?loc: Location }) -> instance
+      end
+
+      class Tokens < Struct[Array[String] | Hash[String, String]? | Location]
         attr_accessor names(): Array[String]
 
+        attr_accessor aliases(): Hash[String, String]?
+
         attr_accessor loc(): Location
 
-        def self.new: (?names: Array[String], ?loc: Location) -> instance
-                    | ({ ?names: Array[String], ?loc: Location }) -> instance
+        def self.new: (?names: Array[String], ?aliases: Hash[String, String]?, ?loc: Location) -> instance
+                    | ({ ?names: Array[String], ?aliases: Hash[String, String]?, ?loc: Location }) -> instance
       end
 
       class Precedence < Struct[Symbol | Array[PrecedenceLevel] | Location]
@@ -86,13 +138,88 @@ module Ibex
                     | ({ ?conflicts: Integer, ?loc: Location }) -> instance
       end
 
-      class Start < Struct[String | Location]
+      class ExpectRR < Struct[Integer | Location]
+        attr_accessor conflicts(): Integer
+
+        attr_accessor loc(): Location
+
+        def self.new: (?conflicts: Integer, ?loc: Location) -> instance
+                    | ({ ?conflicts: Integer, ?loc: Location }) -> instance
+      end
+
+      class Start < Struct[Array[String] | Location]
+        attr_accessor names(): Array[String]
+
+        attr_accessor loc(): Location
+
+        def self.new: (?names: Array[String], ?loc: Location) -> instance
+                    | ({ ?names: Array[String], ?loc: Location }) -> instance
+      end
+
+      class Recovery < Struct[Array[String] | Location]
+        attr_accessor sync_tokens(): Array[String]
+
+        attr_accessor loc(): Location
+
+        def self.new: (?sync_tokens: Array[String], ?loc: Location) -> instance
+                    | ({ ?sync_tokens: Array[String], ?loc: Location }) -> instance
+      end
+
+      class OnErrorReduce < Struct[Array[String] | Location]
+        attr_accessor names(): Array[String]
+
+        attr_accessor loc(): Location
+
+        def self.new: (?names: Array[String], ?loc: Location) -> instance
+                    | ({ ?names: Array[String], ?loc: Location }) -> instance
+      end
+
+      class GrammarTest < Struct[Symbol | String | Location]
+        attr_accessor expectation(): Symbol
+
+        attr_accessor source(): String
+
+        attr_accessor loc(): Location
+
+        def self.new: (?expectation: Symbol, ?source: String, ?loc: Location) -> instance
+                    | ({ ?expectation: Symbol, ?source: String, ?loc: Location }) -> instance
+      end
+
+      class Lexer < Struct[Array[lexer_entry] | Location]
+        attr_accessor definitions(): Array[lexer_entry]
+
+        attr_accessor loc(): Location
+
+        def self.new: (?definitions: Array[lexer_entry], ?loc: Location) -> instance
+                    | ({ ?definitions: Array[lexer_entry], ?loc: Location }) -> instance
+      end
+
+      class LexerRule < Struct[Symbol | String? | String | Location]
+        attr_accessor kind(): Symbol
+
+        attr_accessor token(): String?
+
+        attr_accessor pattern(): String
+
+        attr_accessor pattern_kind(): Symbol
+
+        attr_accessor action(): String?
+
+        attr_accessor loc(): Location
+
+        def self.new: (?kind: Symbol, ?token: String?, ?pattern: String, ?pattern_kind: Symbol, ?action: String?, ?loc: Location) -> instance
+                    | ({ ?kind: Symbol, ?token: String?, ?pattern: String, ?pattern_kind: Symbol, ?action: String?, ?loc: Location }) -> instance
+      end
+
+      class LexerState < Struct[String | Array[lexer_entry] | Location]
         attr_accessor name(): String
 
+        attr_accessor definitions(): Array[lexer_entry]
+
         attr_accessor loc(): Location
 
-        def self.new: (?name: String, ?loc: Location) -> instance
-                    | ({ ?name: String, ?loc: Location }) -> instance
+        def self.new: (?name: String, ?definitions: Array[lexer_entry], ?loc: Location) -> instance
+                    | ({ ?name: String, ?definitions: Array[lexer_entry], ?loc: Location }) -> instance
       end
 
       class Convert < Struct[Array[Conversion] | Location]
@@ -115,28 +242,96 @@ module Ibex
                     | ({ ?name: String, ?expression: String, ?loc: Location }) -> instance
       end
 
-      class Rule < Struct[String | Array[Alternative] | Location]
-        attr_accessor lhs(): String
+      class DisplayName < Struct[String | Location]
+        attr_accessor name(): String
+
+        attr_accessor value(): String
+
+        attr_accessor loc(): Location
+
+        def self.new: (?name: String, ?value: String, ?loc: Location) -> instance
+                    | ({ ?name: String, ?value: String, ?loc: Location }) -> instance
+      end
+
+      class SemanticType < Struct[String | Location]
+        attr_accessor name(): String
+
+        attr_accessor value(): String
+
+        attr_accessor loc(): Location
+
+        def self.new: (?name: String, ?value: String, ?loc: Location) -> instance
+                    | ({ ?name: String, ?value: String, ?loc: Location }) -> instance
+      end
+
+      class Parameter < Struct[String | String? | Location]
+        attr_accessor name(): String
+
+        attr_accessor semantic_type(): String?
+
+        attr_accessor loc(): Location
+
+        def self.new: (?name: String, ?semantic_type: String?, ?loc: Location) -> instance
+                    | ({ ?name: String, ?semantic_type: String?, ?loc: Location }) -> instance
+      end
+
+      class Printer < Struct[String | Location]
+        attr_accessor name(): String
+
+        attr_accessor code(): String
+
+        attr_accessor loc(): Location
+
+        def self.new: (?name: String, ?code: String, ?loc: Location) -> instance
+                    | ({ ?name: String, ?code: String, ?loc: Location }) -> instance
+      end
+
+      class ParserConfiguration < Struct[Array[ParserSetting] | Location]
+        attr_accessor settings(): Array[ParserSetting]
+
+        attr_accessor loc(): Location
 
-        attr_accessor alternatives(): Array[Alternative]
+        def self.new: (?settings: Array[ParserSetting], ?loc: Location) -> instance
+                    | ({ ?settings: Array[ParserSetting], ?loc: Location }) -> instance
+      end
+
+      class ParserSetting < Struct[Symbol | Location]
+        attr_accessor key(): Symbol
+
+        attr_accessor value(): Symbol
 
         attr_accessor loc(): Location
 
-        def self.new: (?lhs: String, ?alternatives: Array[Alternative], ?loc: Location) -> instance
-                    | ({ ?lhs: String, ?alternatives: Array[Alternative], ?loc: Location }) -> instance
+        def self.new: (?key: Symbol, ?value: Symbol, ?loc: Location) -> instance
+                    | ({ ?key: Symbol, ?value: Symbol, ?loc: Location }) -> instance
       end
 
-      class Alternative < Struct[Array[item] | InlineAction? | String? | Location]
+      ROOT_ONLY_DECLARATION_NAMES: Hash[Class, String]
+
+      class Alternative < Struct[Array[item] | InlineAction? | String? | NodeAnnotation? | Location]
         attr_accessor items(): Array[item]
 
         attr_accessor action(): InlineAction?
 
         attr_accessor precedence(): String?
 
+        attr_accessor node_annotation(): NodeAnnotation?
+
         attr_accessor loc(): Location
 
-        def self.new: (?items: Array[item], ?action: InlineAction?, ?precedence: String?, ?loc: Location) -> instance
-                    | ({ ?items: Array[item], ?action: InlineAction?, ?precedence: String?, ?loc: Location }) -> instance
+        def self.new: (?items: Array[item], ?action: InlineAction?, ?precedence: String?, ?node_annotation: NodeAnnotation?, ?loc: Location) -> instance
+                    | ({ ?items: Array[item], ?action: InlineAction?, ?precedence: String?, ?node_annotation: NodeAnnotation?, ?loc: Location }) -> instance
+      end
+
+      class NodeAnnotation < Struct[String | Array[String] | Location]
+        attr_accessor name(): String
+
+        attr_accessor fields(): Array[String]
+
+        attr_accessor loc(): Location
+
+        def self.new: (?name: String, ?fields: Array[String], ?loc: Location) -> instance
+                    | ({ ?name: String, ?fields: Array[String], ?loc: Location }) -> instance
       end
 
       class SymbolReference < Struct[String | String? | Location]
@@ -150,6 +345,19 @@ module Ibex
                     | ({ ?name: String, ?named_reference: String?, ?loc: Location }) -> instance
       end
 
+      class ParameterizedReference < Struct[String | Array[item] | String? | Location]
+        attr_accessor name(): String
+
+        attr_accessor arguments(): Array[item]
+
+        attr_accessor named_reference(): String?
+
+        attr_accessor loc(): Location
+
+        def self.new: (?name: String, ?arguments: Array[item], ?named_reference: String?, ?loc: Location) -> instance
+                    | ({ ?name: String, ?arguments: Array[item], ?named_reference: String?, ?loc: Location }) -> instance
+      end
+
       class InlineAction < Struct[String | Location]
         attr_accessor code(): String
 
@@ -159,6 +367,13 @@ module Ibex
                     | ({ ?code: String, ?loc: Location }) -> instance
       end
 
+      class Empty < Struct[Location]
+        attr_accessor loc(): Location
+
+        def self.new: (?loc: Location) -> instance
+                    | ({ ?loc: Location }) -> instance
+      end
+
       class Optional < Struct[item | Location]
         attr_accessor item(): item
 

data/sig/ibex/frontend/bootstrap_parser.rbs

@@ -8,6 +8,10 @@ module Ibex
 
       include BootstrapParserRules
 
+      include BootstrapParserParameters
+
+      include ParserConfigurationSupport
+
       @mode: Symbol
 
       @index: Integer
@@ -20,8 +24,17 @@ module Ibex
       # @rbs () -> AST::Root
       def parse: () -> AST::Root
 
+      # @rbs () -> AST::Fragment
+      def parse_fragment: () -> AST::Fragment
+
       private
 
+      # @rbs (Array[AST::declaration] declarations) -> void
+      def reject_fragment_root_declarations: (Array[AST::declaration] declarations) -> void
+
+      # @rbs (AST::declaration declaration) -> String?
+      def fragment_root_declaration_name: (AST::declaration declaration) -> String?
+
       # @rbs () -> String
       def parse_constant_path: () -> String
 

data/sig/ibex/frontend/diagnostic.rbs

@@ -0,0 +1,53 @@
+# Generated from lib/ibex/frontend/diagnostic.rb with RBS::Inline
+
+module Ibex
+  module Frontend
+    # An immutable machine-readable frontend error.
+    class Diagnostic
+      attr_reader code: String
+
+      attr_reader phase: Symbol
+
+      attr_reader message: String
+
+      attr_reader location: Location
+
+      attr_reader span: SourceSpan?
+
+      attr_reader expected: Array[String]
+
+      attr_reader received: String?
+
+      # @rbs (code: String, phase: Symbol, message: String, location: Location, ?span: SourceSpan?,
+      #   ?expected: Array[String], ?received: String?, ?rendered: String?) -> void
+      def initialize: (code: String, phase: Symbol, message: String, location: Location, ?span: SourceSpan?, ?expected: Array[String], ?received: String?, ?rendered: String?) -> void
+
+      # @rbs () -> String
+      def severity: () -> String
+
+      # @rbs () -> String
+      def to_s: () -> String
+
+      # @rbs () -> Hash[Symbol, Object?]
+      def to_h: () -> Hash[Symbol, Object?]
+    end
+
+    # Immutable output from a diagnostic parse.
+    class ParseResult
+      attr_reader diagnostics: Array[Diagnostic]
+
+      attr_reader ast: AST::Root?
+
+      attr_reader document: SourceDocument?
+
+      # @rbs (diagnostics: Array[Diagnostic], ast: AST::Root?, document: SourceDocument?) -> void
+      def initialize: (diagnostics: Array[Diagnostic], ast: AST::Root?, document: SourceDocument?) -> void
+
+      # @rbs () -> bool
+      def success?: () -> bool
+
+      # @rbs () -> bool
+      def partial?: () -> bool
+    end
+  end
+end

data/sig/ibex/frontend/diagnostic_recovery.rbs

@@ -0,0 +1,98 @@
+# Generated from lib/ibex/frontend/diagnostic_recovery.rb with RBS::Inline
+
+module Ibex
+  module Frontend
+    # Re-runs the generated parser after suppressing only conservative source regions.
+    class DiagnosticRecovery
+      DECLARATION_STARTS: Array[String]
+
+      @suppressed: Hash[Integer, bool]
+
+      @max_diagnostics: Integer
+
+      @mode: Symbol
+
+      @tokens: Array[Token]
+
+      # @rbs (Array[Token] tokens, mode: Symbol, max_diagnostics: Integer) -> void
+      def initialize: (Array[Token] tokens, mode: Symbol, max_diagnostics: Integer) -> void
+
+      # @rbs () -> [AST::Root | AST::Fragment | nil, Array[Diagnostic]]
+      def parse: () -> [ AST::Root | AST::Fragment | nil, Array[Diagnostic] ]
+
+      private
+
+      # @rbs () -> (AST::Root | AST::Fragment | nil)
+      def parse_until_stable: () -> (AST::Root | AST::Fragment | nil)
+
+      # @rbs () -> Array[Token]
+      def working_tokens: () -> Array[Token]
+
+      # @rbs (Diagnostic diagnostic) -> void
+      def append_diagnostic: (Diagnostic diagnostic) -> void
+
+      # @rbs (Diagnostic diagnostic) -> [String, String, Integer, Integer, String]
+      def diagnostic_key: (Diagnostic diagnostic) -> [ String, String, Integer, Integer, String ]
+
+      # @rbs () -> Array[Diagnostic]
+      def sorted_diagnostics: () -> Array[Diagnostic]
+
+      # @rbs (Diagnostic diagnostic) -> [String, Integer, Integer, String, String]
+      def diagnostic_sort_key: (Diagnostic diagnostic) -> [ String, Integer, Integer, String, String ]
+
+      # @rbs (Token? token, Exception error) -> Range[Integer]?
+      def suppression_range: (Token? token, Exception error) -> Range[Integer]?
+
+      # @rbs (Token? token) -> Integer?
+      def token_index: (Token? token) -> Integer?
+
+      # @rbs (String message) -> Integer?
+      def token_index_for_message: (String message) -> Integer?
+
+      # @rbs () -> Integer?
+      def rule_marker_index: () -> Integer?
+
+      # @rbs (Integer failure, Integer rule_marker) -> Range[Integer]?
+      def declaration_range: (Integer failure, Integer rule_marker) -> Range[Integer]?
+
+      # @rbs (Integer index) -> bool
+      def declaration_start?: (Integer index) -> bool
+
+      # @rbs (Integer start, Integer rule_marker, Array[Integer] starts) -> Integer
+      def declaration_finish: (Integer start, Integer rule_marker, Array[Integer] starts) -> Integer
+
+      # @rbs (Integer start, Integer fallback, String closer) -> Integer
+      def matching_declaration_end: (Integer start, Integer fallback, String closer) -> Integer
+
+      # @rbs (Integer failure, Integer rule_marker) -> Range[Integer]?
+      def rule_range: (Integer failure, Integer rule_marker) -> Range[Integer]?
+
+      # @rbs (Integer rule_marker) -> Integer
+      def grammar_end_index: (Integer rule_marker) -> Integer
+
+      # @rbs (Integer rule_marker, Integer grammar_end) -> Array[Integer]
+      def rule_definition_starts: (Integer rule_marker, Integer grammar_end) -> Array[Integer]
+
+      # @rbs (Integer index, Integer? lhs_column) -> bool
+      def lhs_candidate?: (Integer index, Integer? lhs_column) -> bool
+
+      # @rbs (Integer failure, Integer start, Integer finish) -> Range[Integer]?
+      def alternative_range: (Integer failure, Integer start, Integer finish) -> Range[Integer]?
+
+      # @rbs (Integer? previous, Integer? following, Integer colon, Integer finish) -> Range[Integer]?
+      def alternative_slice: (Integer? previous, Integer? following, Integer colon, Integer finish) -> Range[Integer]?
+
+      # @rbs (Integer start, Integer finish) -> Array[Integer]
+      def top_level_pipes: (Integer start, Integer finish) -> Array[Integer]
+
+      # @rbs (Range[Integer] range) -> bool
+      def suppress: (Range[Integer] range) -> bool
+
+      # @rbs (Exception error, Token? token, phase: Symbol) -> Diagnostic
+      def diagnostic_from: (Exception error, Token? token, phase: Symbol) -> Diagnostic
+
+      # @rbs (String message) -> [Array[String], String?]
+      def expected_and_received: (String message) -> [ Array[String], String? ]
+    end
+  end
+end

data/sig/ibex/frontend/dsl.rbs

@@ -35,12 +35,36 @@ module Ibex
         # @rbs (Integer conflicts) -> void
         def expect: (Integer conflicts) -> void
 
-        # @rbs (Object name) -> void
-        def start: (Object name) -> void
+        # @rbs (*Object names) -> void
+        def start: (*Object names) -> void
+
+        # @rbs (*Object names) -> void
+        def recover_sync: (*Object names) -> void
+
+        # @rbs (*Object names) -> void
+        def on_error_reduce: (*Object names) -> void
+
+        # @rbs (Object source) -> void
+        def test_accept: (Object source) -> void
+
+        # @rbs (Object source) -> void
+        def test_reject: (Object source) -> void
 
         # @rbs (Object name, Object expression) -> void
         def convert: (Object name, Object expression) -> void
 
+        # @rbs (Object name, Object value) -> void
+        def display: (Object name, Object value) -> void
+
+        # @rbs (Object name, Object value) -> void
+        def type: (Object name, Object value) -> void
+
+        # @rbs (Object name, ?Object? semantic_type) -> void
+        def param: (Object name, ?Object? semantic_type) -> void
+
+        # @rbs (Object name, Object code) -> void
+        def printer: (Object name, Object code) -> void
+
         # @rbs (?direction: Symbol) { (PrecedenceBuilder) -> void } -> void
         def precedence: (?direction: Symbol) { (PrecedenceBuilder) -> void } -> void
 
@@ -79,6 +103,11 @@ module Ibex
 
         # @rbs () -> Location
         def next_location: () -> Location
+
+        private
+
+        # @rbs (Object value, String feature) -> String
+        def metadata_value: (Object value, String feature) -> String
       end
 
       # Collects ordered associativity levels.
@@ -116,8 +145,8 @@ module Ibex
         # @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
+        # @rbs (*Object items, ?action: Object?, ?precedence: Object?, ?node: AST::NodeAnnotation?) -> void
+        def alt: (*Object items, ?action: Object?, ?precedence: Object?, ?node: AST::NodeAnnotation?) -> void
       end
     end
   end