Trying to match a rule with match_examples()

[cdroege]

I am implementing an error reporting method with the help of match_examples(), but it seems that I would have to define a lot of error examples that are nearly the same. Here is a unit test with a minimal grammar:

import inspect
import unittest

from lark import Lark
from lark.exceptions import UnexpectedToken

GRAMMAR = r"""
    ?document: (paragraph|environment_command)*

    paragraph: words newline

    ?environment_command: list

    ?words: WORDS
    ?newline: NEWLINE

    list: start_list bullets+ end_list
    start_list:  "\\list" newline
    end_list: "\\endlist" newline
    bullets: "\\bullet" words newline

    WORDS: /[@$~%*.,:;?!&#|<>=+'\-\(\)\[\]\/\"\^\w ]/+
    %import common.WS
    %import common.NEWLINE
"""


parser = Lark(GRAMMAR, parser="lalr", start="document", lexer="contextual",)


class MissingBulletPointException(Exception):
    pass


error_example = {MissingBulletPointException: ["\\list\n\\endlist\n", "\\list\nsome words\n\\endlist\n"]}


class TestMatchExamples(unittest.TestCase):
    def test_valid_input(self):
        document = inspect.cleandoc(
            r"""
                Text

                \list
                \bullet bla
                \endlist

                """
        )
        document = document + "\n"

        parser.parse(document + "\n")

    def test_preceding_text(self):
        document = inspect.cleandoc(
            r"""
                Text

                \list
                \endlist
                """
        )
        document = document + "\n"

        try:
            parser.parse(document)
        except UnexpectedToken as exc:
            exc_class = exc.match_examples(parser.parse, error_example, use_accepts=True)

            self.assertEqual(exc_class, MissingBulletPointException)

    def test_no_preceding_text(self):
        document = inspect.cleandoc(
            r"""
                \list
                \endlist
                """
        )
        document = document + "\n"

        try:
            parser.parse(document)
        except UnexpectedToken as exc:
            exc_class = exc.match_examples(parser.parse, error_example, use_accepts=True)

            self.assertEqual(exc_class, MissingBulletPointException)


if __name__ == "__main__":
    unittest.main()

The test_no_preceding_text test works as it should, but in the test_preceding_text test the match_examples call returns None. It seems that the parser creates different states for these inputs:

1. document -> paragraph -> environment_command -> list
2. document -> environment_command -> list

I could another error example for this additional case, but that is not really feasible for my (full) grammar as there are a lot of different ways a rule can be reached.

My question is: Is there a simpler way to implement the error reporting? For me, I only want to catch errors for a specific rule in isolation and it is not really important for me which rules were previously used to reach this rule