parsanol 1.3.105 → 1.3.106

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3954375840e755bd28df5e62048c4ec4dc94ab56a5917c839e04901e95290c2f
-  data.tar.gz: ec2e66f50dab4a8e6cc30651d9b4fe6ec468e4441a1c62b697f3a28d61e86167
+  metadata.gz: cb8829be859854aad36e7ed1a0b43675af3295f714fb86ef9ee0af9cabf491ec
+  data.tar.gz: 73137433d9c3676ca771f696cccda01d8f87770a638fcc4eb0ea92332ff974f9
 SHA512:
-  metadata.gz: 465b6dfa7765cf143cc78bd7eab75bf8c8c7bf9d20a859930a868be5563de33e44f50e2844a519f9179d4d1dbe9836a4392042c573cf58dbd106e110bf67a26c
-  data.tar.gz: 06c14f1c1111606323b4ec1e3c895a88fbb9109440158ed68eab0094840c9ce38e366bc2e049653790257873f720755196087d16abdc29aad3afbd8d07b3af54
+  metadata.gz: 28d0a98e32e8e46bcc645a2e8f13782518470192ce96c27a733edcca920025c6546fc1f2041acb4b069fd1ced2430fe8ef3b186ade399c9df68b0cfaac345018
+  data.tar.gz: 192af56c8f394b99de8fcc0b0ba4683e807bc19f4448900df53b38afe51821f57f2c17dc76f1884f6d12d201c3edb72bc2e745ccce9ac84a1f7eac7ec2825faa

data/Cargo.lock

@@ -307,9 +307,9 @@ checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
 
 [[package]]
 name = "parsanol"
-version = "0.18.16"
+version = "0.18.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "597e0971251e10f0d9fac99a9f217dc2ce8e5607df9f93d2a12a5e4d823d0ee9"
+checksum = "6dcea9d4de103b4ecba2f58de7634ec009f809c93150f658f056b7ad65ee3d97"
 dependencies = [
  "ahash",
  "getrandom 0.3.4",
@@ -326,9 +326,9 @@ dependencies = [
 
 [[package]]
 name = "parsanol-derive"
-version = "0.18.16"
+version = "0.18.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "342e298363272c74478384205a3d6def7905d8277945d65ad203606596de7fe6"
+checksum = "6e222a36678bd337b7d8484c81e731796cc5b2bb6c3fd654d29563380d4ba883"
 dependencies = [
  "proc-macro2",
  "quote",

data/lib/parsanol/parg/artifact.rb

@@ -250,44 +250,82 @@ module Parsanol
         return [[], []] unless body_rule
 
         body_atom = compiler.atom_for(body_rule)
+        # R2 declared form: the baked resync pattern owns the skip
+        # spans (author-deterministic — no trial scanning). Falls back
+        # to the inferred trial scan when the rule declares none.
+        pattern_atom = compiler.resync_atom_for(body_rule) ||
+          compiler.resync_atom_for(entry(entry_name)["root"])
         max = input.length
         resyncs = []
         items = []
         rounds = 0
         while rounds < 8
-          found = nil
-          scan = cursor
-          while scan < max
-            attempt = try_iteration(body_atom, input, scan)
-            if attempt && attempt[1] > scan
-              found = [scan, attempt[1], attempt[0]]
-              break
+          attempt = try_iteration(body_atom, input, cursor)
+          if attempt
+            items << root_atom(entry_name).flatten(attempt[0])
+            cursor = attempt[1]
+            until cursor >= max
+              attempt = try_iteration(body_atom, input, cursor)
+              break unless attempt
+
+              items << root_atom(entry_name).flatten(attempt[0])
+              cursor = attempt[1]
             end
-            scan += 1
+            break if cursor >= max
+          end
+          if pattern_atom
+            # Declared: the pattern match (gap + delimiter) is the
+            # annotated error span.
+            span = scan_pattern(pattern_atom, input, cursor)
+            break unless span
+
+            resume = span[1]
+            resyncs << {
+              "offset" => cursor,
+              "skipped" => input[cursor...resume],
+              "resumed_at" => resume,
+            }
+          else
+            # Inferred: scan for the next viable iteration start.
+            found = nil
+            scan = cursor
+            while scan < max
+              attempt = try_iteration(body_atom, input, scan)
+              if attempt && attempt[1] > scan
+                found = [scan, attempt[1], attempt[0]]
+                break
+              end
+              scan += 1
+            end
+            break unless found
+
+            skip_start, resume, value = found
+            resyncs << {
+              "offset" => cursor,
+              "skipped" => input[cursor...skip_start],
+              "resumed_at" => skip_start,
+            }
+            items << root_atom(entry_name).flatten(value)
           end
-          break unless found
-
-          skip_start, resume, value = found
-          resyncs << {
-            "offset" => cursor,
-            "skipped" => input[cursor...skip_start],
-            "resumed_at" => skip_start,
-          }
-          items << root_atom(entry_name).flatten(value)
           cursor = resume
           rounds += 1
-          until cursor >= max
-            attempt = try_iteration(body_atom, input, cursor)
-            break unless attempt && attempt[1] > cursor
-
-            items << root_atom(entry_name).flatten(attempt[0])
-            cursor = attempt[1]
-          end
-          break if cursor >= max
         end
         [items, resyncs]
       end
 
+      # Scan forward from `from` for the first position where the
+      # declared pattern matches with progress: [match_start, match_end].
+      def scan_pattern(pattern_atom, input, from)
+        scan = from
+        while scan < input.length
+          attempt = try_iteration(pattern_atom, input, scan)
+          return [scan, attempt[1]] if attempt
+
+          scan += 1
+        end
+        nil
+      end
+
       # Apply the body atom at one position: [value, end_pos] on a
       # progressing match, nil otherwise.
       def try_iteration(atom, input, pos)

data/lib/parsanol/parg/compiler.rb

@@ -130,6 +130,17 @@ module Parsanol
               "(bind the class before compiling, or fix the custom declaration)"
       end
 
+      # The declared resync skip pattern for a rule, built as a raw
+      # atom (no trivia injection). Nil when the rule declares none.
+      def resync_atom_for(rule)
+        pattern = @document.resyncs[rule.to_sym] || @document.resyncs[rule.to_s]
+        return nil unless pattern
+
+        expand_left_recursion! unless @expanded
+        @resync_cache ||= {}
+        @resync_cache[rule.to_sym] ||= build_atom(pattern)
+      end
+
       def atom_for(name)
         expand_left_recursion! unless @expanded
         @atom_cache[name] ||= begin
@@ -925,6 +936,12 @@ module Parsanol
       end
 
       def build_envelope
+        @document.resyncs.each_key do |target|
+          unless @document.rules.key?(target.to_sym) ||
+              @document.rules.key?(target.to_s)
+            raise CompileError, "resync declared for unknown rule #{target.inspect}"
+          end
+        end
         entries = @document.entries.to_h do |name, rule|
           [name, entry_envelope(rule)]
         end
@@ -980,11 +997,20 @@ module Parsanol
       end
 
       def entry_envelope(rule)
-        {
+        envelope = {
           "root" => rule,
           "grammar" => JSON.parse(portable_json(rule)),
           "bindings" => binding_list(rule),
         }
+        # R2 declared resync: the skip pattern bakes as its own
+        # mini-grammar (same portable atoms shape) so every engine
+        # matches identical error spans. Raw match — no trivia
+        # injection: the pattern delimits junk, it is not syntax.
+        if (pattern = @document.resyncs[rule.to_sym] || @document.resyncs[rule.to_s])
+          envelope["resync"] =
+            JSON.parse(Parsanol::Native::Parser.serialize_grammar(build_atom(pattern)))
+        end
+        envelope
       end
 
       def portable_json(rule)

data/lib/parsanol/parg/document.rb

@@ -19,6 +19,9 @@ module Parsanol
 
       attr_accessor :grammar_name, :version, :source, :uses, :skip_declaration, :skip_source,
                     :atomic_rules, :skip_capture_key
+      # R2 declared resync: rule name -> skip pattern (the span matched
+      # at a recovery point is consumed as annotated error text).
+      attr_reader :resyncs
       attr_reader :rules, :bindings, :preprocess, :entries, :docs, :tests, :render, :derive,
                   :customs, :states
       # Entries authored in this file (pre-import); nil-entry tests resolve
@@ -45,6 +48,10 @@ module Parsanol
         # suppressed inside their bodies (token-shaped rules match
         # contiguously).
         @atomic_rules = []
+        # R2 declared resync: rule -> skip pattern. Recovery consumes
+        # each pattern match at a failure point as annotated error text
+        # and resumes the iteration after it.
+        @resyncs = {}
       end
 
       def validate!

data/lib/parsanol/parg/parser.rb

@@ -257,6 +257,22 @@ module Parsanol
             skip_newlines
             next
           end
+          if peek&.type == :ident && peek.value == "resync"
+            advance
+            target = rule_name
+            punct("=")
+            node = parse_choice
+            if document.resyncs.key?(target.to_sym)
+              raise ParseError, "duplicate resync declaration for #{target.inspect}"
+            end
+
+            # The target rule may be declared later in the block
+            # (forward reference, like entry roots); the compiler
+            # rejects unknown targets at compile time.
+            document.resyncs[target.to_sym] = validate_resync_node(node)
+            skip_newlines
+            next
+          end
           if peek&.type == :ident && STATE_KEYWORDS.include?(peek.value)
             keyword = advance.value
             slot = ident.value
@@ -300,6 +316,30 @@ module Parsanol
         end
       end
 
+      # A resync pattern may be any expression EXCEPT captures and
+      # state operations: the span it matches is reported as skipped
+      # error text, so bindings and slots have no meaning inside it,
+      # and a capture would silently drop its data.
+      def validate_resync_node(node)
+        case node.kind
+        when :cap
+          raise ParseError,
+                "resync pattern may not contain captures (the matched " \
+                "span is annotated error text), got :cap"
+        when :seq, :alt
+          node.a.each { |child| validate_resync_node(child) }
+          node
+        when :rep, :opt
+          validate_resync_node(node.a)
+          node
+        when :pred
+          validate_resync_node(node.b)
+          node
+        else
+          node
+        end
+      end
+
       def validate_skip_node(node)
         case node.kind
         when :ref

data/lib/parsanol/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Parsanol
-  VERSION = "1.3.105"
+  VERSION = "1.3.106"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: parsanol
 version: !ruby/object:Gem::Version
-  version: 1.3.105
+  version: 1.3.106
 platform: ruby
 authors:
 - Ribose Inc.